mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-11-21 03:13:42 +08:00
Code Issues Packages Projects Releases Wiki Activity
4e26504e44
netcdf-c/libdispatch/doffsets.c
Dennis Heimbigner 3db4f013bf Primary change: add dap4 support 
Specific changes:
1. Add dap4 code: libdap4 and dap4_test.
   Note that until the d4ts server problem is solved, dap4 is turned off.
2. Modify various files to support dap4 flags:
	configure.ac, Makefile.am, CMakeLists.txt, etc.
3. Add nc_test/test_common.sh. This centralizes
   the handling of the locations of various
   things in the build tree: e.g. where is
   ncgen.exe located. See nc_test/test_common.sh
   for details.
4. Modify .sh files to use test_common.sh
5. Obsolete separate oc2 by moving it to be part of
   netcdf-c. This means replacing code with netcdf-c
   equivalents.
5. Add --with-testserver to configure.ac to allow
   override of the servers to be used for --enable-dap-remote-tests.
6. There were multiple versions of nctypealignment code. Try to
   centralize in libdispatch/doffset.c and include/ncoffsets.h
7. Add a unit test for the ncuri code because of its complexity.
8. Move the findserver code out of libdispatch and into
   a separate, self contained program in ncdap_test and dap4_test.
9. Move the dispatch header files (nc{3,4}dispatch.h) to
   .../include because they are now shared by modules.
10. Revamp the handling of TOPSRCDIR and TOPBUILDDIR for shell scripts.
11. Make use of MREMAP if available
12. Misc. minor changes e.g.
	- #include <config.h> -> #include "config.h"
	- Add some no-install headers to /include
	- extern -> EXTERNL and vice versa as needed
	- misc header cleanup
	- clean up checking for misc. unix vs microsoft functions
13. Change copyright decls in some files to point to LICENSE file.
14. Add notes to RELEASENOTES.md
2017-03-08 17:01:10 -07:00

345 lines
11 KiB
C
Raw Blame History

/*********************************************************************
* Copyright 1993, UCAR/Unidata
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
* $Header: /upc/share/CVS/netcdf-3/ncgen/offsets.c,v 1.1 2009/09/25 18:22:40 dmh Exp $
*********************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
This code is a variantion of the H5detect.c code from HDF5.
Author: D. Heimbigner 10/7/2008
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#ifdef OFFSETTEST
static void* emalloc(size_t);
typedef int nc_type;
typedef struct nc_vlen_t {
size_t len;
void* p;
} nc_vlen_t;
#define NC_NAT 0 /* NAT = 'Not A Type' (c.f. NaN) */
#define NC_BYTE 1 /* signed 1 byte integer */
#define NC_CHAR 2 /* ISO/ASCII character */
#define NC_SHORT 3 /* signed 2 byte integer */
#define NC_INT 4 /* signed 4 byte integer */
#define NC_FLOAT 5 /* single precision floating point number */
#define NC_DOUBLE 6 /* double precision floating point number */
#define NC_UBYTE 7 /* unsigned 1 byte int */
#define NC_USHORT 8 /* unsigned 2-byte int */
#define NC_UINT 9 /* unsigned 4-byte int */
#define NC_INT64 10 /* signed 8-byte int */
#define NC_UINT64 11 /* unsigned 8-byte int */
#define NC_STRING 12 /* string */
#define NC_STRING 12 /* string */
#define NC_VLEN 13
#define NC_OPAQUE 14
#define NC_ENUM 15
#define NC_COMPOUND 16
#endif
#include "netcdf.h"
#include "ncoffsets.h"
/*
The heart of this is the following macro,
which computes the offset of a field x
when preceded by a char field.
The assumptions appear to be as follows:
1. the offset produced in this situation indicates
the alignment for x relative in such a way that it
depends only on the types that precede it in the struct.
2. the compiler does not reorder fields.
3. arrays are tightly packed.
4. nested structs are alignd according to their first member
(this actually follows from C language requirement that
a struct can legally be cast to an instance of its first member).
Given the alignments for the various common primitive types,
it is assumed that one can use them anywhere to construct
the layout of a struct of such types.
It seems to work for HDF5 for a wide variety of machines.
Note that technically, this is compiler dependent, but in practice
all compilers seem to mimic the gcc rules.
*/
#define COMP_ALIGNMENT(DST,TYPE) {\
struct {char f1; TYPE x;} tmp; \
DST.typename = #TYPE ; \
DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
#if 0
char* ctypenames[NCTYPES] = {
(char*)NULL,
"char","unsigned char",
"short","unsigned short",
"int","unsigned int",
"long long","unsigned long long",
"float","double",
"void*","nc_vlen_t"
};
#endif
static Typealignvec vec[NCTYPES];
static Typealignset set;
static int computed = 0;
/*Forward*/
static void compute_alignments(void);
unsigned int
nctypealignment(nc_type nctype)
{
Alignment* align = NULL;
int index = 0;
if(!computed) {
compute_alignments();
computed = 1;
}
switch (nctype) {
case NC_BYTE: index = UCHARINDEX; break;
case NC_CHAR: index = CHARINDEX; break;
case NC_SHORT: index = SHORTINDEX; break;
case NC_INT: index = INTINDEX; break;
case NC_FLOAT: index = FLOATINDEX; break;
case NC_DOUBLE: index = DOUBLEINDEX; break;
case NC_UBYTE: index = UCHARINDEX; break;
case NC_USHORT: index = USHORTINDEX; break;
case NC_UINT: index = UINTINDEX; break;
case NC_INT64: index = LONGLONGINDEX; break;
case NC_UINT64: index = ULONGLONGINDEX; break;
case NC_STRING: index = PTRINDEX; break;
case NC_VLEN: index = NCVLENINDEX; break;
case NC_OPAQUE: index = UCHARINDEX; break;
default:
fprintf(stderr,"nctypealignment: bad type code: %d",nctype);
exit(1);
}
align = &vec[index];
return align->alignment;
}
static void
compute_alignments(void)
{
/* Compute the alignments for all the common C data types*/
/* First for the struct*/
/* initialize*/
memset((void*)&set,0,sizeof(set));
memset((void*)vec,0,sizeof(vec));
COMP_ALIGNMENT(set.charalign,char);
COMP_ALIGNMENT(set.ucharalign,unsigned char);
COMP_ALIGNMENT(set.shortalign,short);
COMP_ALIGNMENT(set.ushortalign,unsigned short);
COMP_ALIGNMENT(set.intalign,int);
COMP_ALIGNMENT(set.uintalign,unsigned int);
COMP_ALIGNMENT(set.longlongalign,long long);
COMP_ALIGNMENT(set.ulonglongalign,unsigned long long);
COMP_ALIGNMENT(set.floatalign,float);
COMP_ALIGNMENT(set.doublealign,double);
COMP_ALIGNMENT(set.ptralign,void*);
COMP_ALIGNMENT(set.ncvlenalign,nc_vlen_t);
/* Then the vector*/
COMP_ALIGNMENT(vec[CHARINDEX],char);
COMP_ALIGNMENT(vec[UCHARINDEX],unsigned char);
COMP_ALIGNMENT(vec[SHORTINDEX],short);
COMP_ALIGNMENT(vec[USHORTINDEX],unsigned short);
COMP_ALIGNMENT(vec[INTINDEX],int);
COMP_ALIGNMENT(vec[UINTINDEX],unsigned int);
COMP_ALIGNMENT(vec[LONGLONGINDEX],long long);
COMP_ALIGNMENT(vec[ULONGLONGINDEX],unsigned long long);
COMP_ALIGNMENT(vec[FLOATINDEX],float);
COMP_ALIGNMENT(vec[DOUBLEINDEX],double);
COMP_ALIGNMENT(vec[PTRINDEX],void*);
COMP_ALIGNMENT(vec[NCVLENINDEX],nc_vlen_t);
}
#ifdef OFFSETTEST
/* Compute the alignment of TYPE when it is preceded
by a field of type TYPE1
*/
#define COMP_ALIGNMENT1(DST,TYPE1,TYPE) {\
struct {TYPE1 f1; TYPE x;} tmp; \
DST.typename = #TYPE ; \
DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
/* Compute the alignment of TYPE when it is preceded
by a field of type TYPE1 and a field of type TYPE2
*/
#define COMP_ALIGNMENT2(DST,TYPE1,TYPE2,TYPE) {\
struct {TYPE1 f1, TYPE2 f2; TYPE x;} tmp; \
DST.typename = #TYPE ; \
DST.alignment = (size_t)((char*)(&(tmp.x)) - (char*)(&tmp));}
/* Compute the alignment of TYPE when it is preceded
by a field of type TYPE1 and a field of type TYPE2
*/
#define COMP_SIZE0(DST,TYPE1,TYPE2) {\
struct {TYPE1 c; TYPE2 x;} tmp; \
DST = sizeof(tmp); }
static char*
padname(char* name)
{
#define MAX 20
if(name == NULL) name = "null";
int len = strlen(name);
if(len > MAX) len = MAX;
char* s = (char*)emalloc(MAX+1);
memset(s,' ',MAX);
s[MAX+1] = '\0';
strncpy(s,name,len);
return s;
}
static void
verify(Typealignvec* vec)
{
int i,j;
Typealignvec* vec16;
Typealignvec* vec32;
int* sizes8;
int* sizes16;
int* sizes32;
vec16 = (Typealignvec*)emalloc(sizeof(Typealignvec)*NCTYPES);
vec32 = (Typealignvec*)emalloc(sizeof(Typealignvec)*NCTYPES);
sizes8 = (int*)emalloc(sizeof(int)*NCTYPES);
sizes16 = (int*)emalloc(sizeof(int)*NCTYPES);
sizes32 = (int*)emalloc(sizeof(int)*NCTYPES);
COMP_SIZE0(sizes8[1],char,char);
COMP_SIZE0(sizes8[2],unsigned char,char);
COMP_SIZE0(sizes8[3],short,char);
COMP_SIZE0(sizes8[4],unsigned short,char);
COMP_SIZE0(sizes8[5],int,char);
COMP_SIZE0(sizes8[6],unsigned int,char);
COMP_SIZE0(sizes8[7],long long,char);
COMP_SIZE0(sizes8[8],unsigned long long,char);
COMP_SIZE0(sizes8[9],float,char);
COMP_SIZE0(sizes8[10],double,char) ;
COMP_SIZE0(sizes8[11],void*,char);
COMP_SIZE0(sizes8[12],nc_vlen_t,char);
COMP_SIZE0(sizes16[1],char,short);
COMP_SIZE0(sizes16[2],unsigned char,short);
COMP_SIZE0(sizes16[3],short,short);
COMP_SIZE0(sizes16[4],unsigned short,short);
COMP_SIZE0(sizes16[5],int,short);
COMP_SIZE0(sizes16[6],unsigned int,short);
COMP_SIZE0(sizes16[7],long long,short);
COMP_SIZE0(sizes16[8],unsigned long long,short);
COMP_SIZE0(sizes16[9],float,short);
COMP_SIZE0(sizes16[10],double,short) ;
COMP_SIZE0(sizes16[11],void*,short);
COMP_SIZE0(sizes16[12],nc_vlen_t*,short);
COMP_SIZE0(sizes32[1],char,int);
COMP_SIZE0(sizes32[2],unsigned char,int);
COMP_SIZE0(sizes32[3],short,int);
COMP_SIZE0(sizes32[4],unsigned short,int);
COMP_SIZE0(sizes32[5],int,int);
COMP_SIZE0(sizes32[6],unsigned int,int);
COMP_SIZE0(sizes32[7],long long,int);
COMP_SIZE0(sizes32[8],unsigned long long,int);
COMP_SIZE0(sizes32[9],float,int);
COMP_SIZE0(sizes32[10],double,int) ;
COMP_SIZE0(sizes32[11],void*,int);
COMP_SIZE0(sizes32[12],nc_vlen_t*,int);
COMP_ALIGNMENT1(vec16[1],char,short);
COMP_ALIGNMENT1(vec16[2],unsigned char,short);
COMP_ALIGNMENT1(vec16[3],short,short);
COMP_ALIGNMENT1(vec16[4],unsigned short,short);
COMP_ALIGNMENT1(vec16[5],int,short);
COMP_ALIGNMENT1(vec16[6],unsigned int,short);
COMP_ALIGNMENT1(vec32[7],long long,short);
COMP_ALIGNMENT1(vec32[8],unsigned long long,short);
COMP_ALIGNMENT1(vec16[9],float,short);
COMP_ALIGNMENT1(vec16[10],double,short);
COMP_ALIGNMENT1(vec16[11],void*,short);
COMP_ALIGNMENT1(vec16[12],nc_vlen_t*,short);
COMP_ALIGNMENT1(vec32[1],char,short);
COMP_ALIGNMENT1(vec32[2],unsigned char,short);
COMP_ALIGNMENT1(vec32[3],char,short);
COMP_ALIGNMENT1(vec32[4],unsigned short,short);
COMP_ALIGNMENT1(vec32[5],int,int);
COMP_ALIGNMENT1(vec32[6],unsigned int,int);
COMP_ALIGNMENT1(vec32[7],long long,int);
COMP_ALIGNMENT1(vec32[8],unsigned long long,int);
COMP_ALIGNMENT1(vec32[9],float,int);
COMP_ALIGNMENT1(vec32[10],double,int);
COMP_ALIGNMENT1(vec32[11],void*,int);
COMP_ALIGNMENT1(vec32[12],nc_vlen_t*,int);
for(i=0;i<NCTYPES;i++) {
printf("%s: size=%2d alignment=%2d\n",
padname(vec[i].typename),sizes8[i],vec[i].alignment);
}
for(i=0;i<NCTYPES;i++) {
printf("short vs %s: size=%2d alignment=%2d\n",
padname(vec[i].typename),sizes16[i],vec16[i].alignment);
}
for(i=0;i<NCTYPES;i++) {
printf("int vs %s: size=%2d alignment=%2d\n",
padname(vec[i].typename),sizes32[i],vec32[i].alignment);
}
}
void *
emalloc(size_t bytes) {
size_t *memory;
memory = malloc(bytes);
if(memory == 0) {
printf("malloc failed\n");
exit(2);
}
return memory;
}
int
main(int argc, char** argv)
{
int i;
compute_alignments();
verify(vec);
/*
for(i=0;i<NCTYPES;i++) {
printf("%s:\talignment=%d\n",vec[i].typename,vec[i].alignment);
}
*/
exit(0);
}
#endif /*OFFSETTEST*/
Reference in New Issue View Git Blame Copy Permalink