diff --git a/include/onstack.h b/include/onstack.h
index bd3b8e39e9..d35895dfb3 100644
--- a/include/onstack.h
+++ b/include/onstack.h
@@ -45,7 +45,7 @@
 #endif /* __GNUC__ */
 
 # if !defined(ALLOCA_ARG_T)
-# define ALLOCA_ARG_T int /* the usual type of the alloca argument */
+# define ALLOCA_ARG_T size_t /* the usual type of the alloca argument */
 # endif
 
 # define ALLOC_ONSTACK(name, type, nelems) \
diff --git a/libsrc/dim.c b/libsrc/dim.c
index dea0fac3dc..eef54e9f93 100644
--- a/libsrc/dim.c
+++ b/libsrc/dim.c
@@ -480,7 +480,7 @@ NC3_rename_dim( int ncid, int dimid, const char *unewname)
 	        NC_hashmapremove(ncp->dims.hashmap, old->cp, strlen(old->cp), NULL);
 		dimp->name = newStr;
 
-		intdata = dimid;
+		intdata = (uintptr_t)dimid;
 		NC_hashmapadd(ncp->dims.hashmap, intdata, newStr->cp, strlen(newStr->cp));
 		free_NC_string(old);
 		goto done;
diff --git a/libsrc/httpio.c b/libsrc/httpio.c
index 17766f1112..56c7bca5a8 100644
--- a/libsrc/httpio.c
+++ b/libsrc/httpio.c
@@ -58,7 +58,7 @@ static int httpio_filesize(ncio* nciop, off_t* filesizep);
 static int httpio_pad_length(ncio* nciop, off_t length);
 static int httpio_close(ncio* nciop, int);
 
-static long pagesize = 0;
+static size_t pagesize = 0;
 
 /* Create a new ncio struct to hold info about the file. */
 static int
@@ -261,7 +261,7 @@ httpio_get(ncio* const nciop, off_t offset, size_t extent, int rflags, void** co
     assert(http->interval == NULL);
     http->interval = ncbytesnew();
     ncbytessetalloc(http->interval,(unsigned long)extent);
-    if((status = nc_http_read(http->state,offset,extent,http->interval)))
+    if((status = nc_http_read(http->state,(size64_t)offset,extent,http->interval)))
 	goto done;
     assert(ncbyteslength(http->interval) == extent);
     if(vpp) *vpp = ncbytescontents(http->interval);
diff --git a/libsrc/memio.c b/libsrc/memio.c
index bc3c601b51..609a0ba98e 100644
--- a/libsrc/memio.c
+++ b/libsrc/memio.c
@@ -9,6 +9,7 @@
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/types.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -130,12 +131,12 @@ static size_t pagesize = 0;
 
 /*! Create a new ncio struct to hold info about the file. */
 static int
-memio_new(const char* path, int ioflags, off_t initialsize, ncio** nciopp, NCMEMIO** memiop)
+memio_new(const char* path, int ioflags, size_t initialsize, ncio** nciopp, NCMEMIO** memiop)
 {
     int status = NC_NOERR;
     ncio* nciop = NULL;
     NCMEMIO* memio = NULL;
-    size_t minsize = (size_t)initialsize;
+    size_t minsize = initialsize;
 
     /* Unlike netcdf-4, INMEMORY and DISKLESS share code */
     if(fIsSet(ioflags,NC_DISKLESS))
@@ -202,7 +203,7 @@ memio_new(const char* path, int ioflags, off_t initialsize, ncio** nciopp, NCMEM
 	nciop->path = NULL;
         free(nciop);
     }
-    memio->alloc = (size_t)initialsize;
+    memio->alloc = initialsize;
     memio->pos = 0;
     memio->size = minsize;
     memio->memory = NULL; /* filled in by caller */
@@ -439,7 +440,7 @@ memio_filesize(ncio* nciop, off_t* filesizep)
     NCMEMIO* memio;
     if(nciop == NULL || nciop->pvt == NULL) return NC_EINVAL;
     memio = (NCMEMIO*)nciop->pvt;
-    if(filesizep != NULL) *filesizep = memio->size;
+    if(filesizep != NULL) *filesizep = (off_t)memio->size;
     return NC_NOERR;
 }
 
@@ -542,14 +543,13 @@ static int
 guarantee(ncio* nciop, off_t endpoint0)
 {
     NCMEMIO* memio = (NCMEMIO*)nciop->pvt;
-    size_t endpoint = (size_t)endpoint0;
-    if(endpoint > memio->alloc) {
+    if(endpoint0 > memio->alloc) {
 	/* extend the allocated memory and size */
-	int status = memio_pad_length(nciop,endpoint);
+	int status = memio_pad_length(nciop,endpoint0);
 	if(status != NC_NOERR) return status;
     }
-    if(memio->size < endpoint)
-	memio->size = endpoint;
+    if(memio->size < endpoint0)
+	memio->size = (size_t)endpoint0;
     return NC_NOERR;
 }
 
diff --git a/libsrc/mmapio.c b/libsrc/mmapio.c
index 13bea6c029..98b9ddb4e8 100644
--- a/libsrc/mmapio.c
+++ b/libsrc/mmapio.c
@@ -93,7 +93,7 @@ typedef struct NCMMAPIO {
     int locked; /* => we cannot realloc */
     int persist; /* => save to a file; triggered by NC_PERSIST */
     char* memory;
-    off_t alloc;
+    size_t alloc;
     off_t size;
     off_t pos;
     int mapfd;
@@ -111,11 +111,11 @@ static int mmapio_close(ncio* nciop, int);
 /* Mnemonic */
 #define DOOPEN 1
 
-static long pagesize = 0;
+static size_t pagesize = 0;
 
 /* Create a new ncio struct to hold info about the file. */
 static int
-mmapio_new(const char* path, int ioflags, off_t initialsize, ncio** nciopp, NCMMAPIO** mmapp)
+mmapio_new(const char* path, int ioflags, size_t initialsize, ncio** nciopp, NCMMAPIO** mmapp)
 {
     int status = NC_NOERR;
     ncio* nciop = NULL;
@@ -124,9 +124,9 @@ mmapio_new(const char* path, int ioflags, off_t initialsize, ncio** nciopp, NCMM
 
     if(pagesize == 0) {
 #if defined HAVE_SYSCONF
-        pagesize = sysconf(_SC_PAGE_SIZE);
+        pagesize = (size_t)sysconf(_SC_PAGE_SIZE);
 #elif defined HAVE_GETPAGESIZE
-        pagesize = getpagesize();
+        pagesize = (size_t)getpagesize();
 #else
         pagesize = 4096; /* good guess */
 #endif
@@ -247,11 +247,11 @@ mmapio_create(const char* path, int ioflags,
         if(fd < 0) {status = errno; goto unwind_open;}
 	mmapio->mapfd = fd;
 
-	{ /* Cause the output file to have enough allocated space */
-	lseek(fd,mmapio->alloc-1,SEEK_SET); /* cause file to appear */
-        write(fd,"",1);
-	lseek(fd,0,SEEK_SET); /* rewind */
-	}
+        { /* Cause the output file to have enough allocated space */
+            lseek(fd,(off_t)mmapio->alloc-1,SEEK_SET); /* cause file to appear */
+            write(fd,"",1);
+            lseek(fd,0,SEEK_SET); /* rewind */
+        }
         mmapio->memory = (char*)mmap(NULL,mmapio->alloc,
                                     PROT_READ|PROT_WRITE,
 				    MAP_SHARED,
@@ -313,7 +313,7 @@ mmapio_open(const char* path,
     void* parameters,
     ncio* *nciopp, void** const mempp)
 {
-    ncio* nciop;
+    ncio* nciop = NULL;
     int fd;
     int status;
     int oflags;
@@ -345,7 +345,7 @@ mmapio_open(const char* path,
     if(filesize < (off_t)sizehint)
         filesize = (off_t)sizehint;
 
-    status = mmapio_new(path, ioflags, filesize, &nciop, &mmapio);
+    status = mmapio_new(path, ioflags, (size_t)filesize, &nciop, &mmapio);
     if(status != NC_NOERR)
 	return status;
     mmapio->size = filesize;
@@ -360,7 +360,7 @@ fprintf(stderr,"mmapio_open: initial memory: %lu/%lu\n",(unsigned long)mmapio->m
 #endif
 
     /* Use half the filesize as the blocksize */
-    sizehint = filesize/2;
+    sizehint = (size_t)filesize/2;
 
     /* sizehint must be multiple of 8 */
     sizehint = (sizehint / 8) * 8;
@@ -425,7 +425,7 @@ mmapio_pad_length(ncio* nciop, off_t length)
 
     if(length > mmapio->alloc) {
         /* Realloc the allocated memory to a multiple of the pagesize*/
-	off_t newsize = length;
+	size_t newsize = (size_t)length;
 	void* newmem = NULL;
 	/* Round to a multiple of pagesize */
 	if((newsize % pagesize) != 0)
@@ -435,7 +435,7 @@ mmapio_pad_length(ncio* nciop, off_t length)
 	{ /* Cause the output file to have enough allocated space */
 	off_t pos = lseek(mmapio->mapfd,0,SEEK_CUR); /* save current position*/
 	/* cause file to be extended in size */
-	lseek(mmapio->mapfd,newsize-1,SEEK_SET);
+	lseek(mmapio->mapfd,(off_t)newsize-1,SEEK_SET);
         write(mmapio->mapfd,"",mmapio->alloc);
 	lseek(mmapio->mapfd,pos,SEEK_SET); /* reset position */
 	}
@@ -524,7 +524,7 @@ mmapio_get(ncio* const nciop, off_t offset, size_t extent, int rflags, void** co
     NCMMAPIO* mmapio;
     if(nciop == NULL || nciop->pvt == NULL) return NC_EINVAL;
     mmapio = (NCMMAPIO*)nciop->pvt;
-    status = guarantee(nciop, offset+extent);
+    status = guarantee(nciop, offset+(off_t)extent);
     mmapio->locked++;
     if(status != NC_NOERR) return status;
     if(vpp) *vpp = mmapio->memory+offset;
@@ -544,11 +544,11 @@ mmapio_move(ncio* const nciop, off_t to, off_t from, size_t nbytes, int ignored)
     mmapio = (NCMMAPIO*)nciop->pvt;
     if(from < to) {
        /* extend if "to" is not currently allocated */
-       status = guarantee(nciop,to+nbytes);
+       status = guarantee(nciop, to + (off_t)nbytes);
        if(status != NC_NOERR) return status;
     }
     /* check for overlap */
-    if((to + nbytes) > from || (from + nbytes) > to) {
+    if((to + (off_t)nbytes) > from || (from + (off_t)nbytes) > to) {
 	/* Ranges overlap */
 #ifdef HAVE_MEMMOVE
         memmove((void*)(mmapio->memory+to),(void*)(mmapio->memory+from),nbytes);
diff --git a/libsrc/nc3internal.c b/libsrc/nc3internal.c
index 0916cc9500..2353148003 100644
--- a/libsrc/nc3internal.c
+++ b/libsrc/nc3internal.c
@@ -10,6 +10,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include <sys/types.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -153,7 +154,7 @@ NC_begins(NC3_INFO* ncp,
 	size_t v_minfree, size_t r_align)
 {
 	size_t ii, j;
-	int sizeof_off_t;
+	size_t sizeof_off_t;
 	off_t index = 0;
 	off_t old_ncp_begin_var;
 	NC_var **vpp;
@@ -186,7 +187,7 @@ NC_begins(NC3_INFO* ncp,
 	{
 	  index = (off_t) ncp->xsz;
 	  ncp->begin_var = D_RNDUP(index, v_align);
-	  if(ncp->begin_var < index + h_minfree)
+	  if(ncp->begin_var < index + (off_t)h_minfree)
 	  {
 	    ncp->begin_var = D_RNDUP(index + (off_t)h_minfree, v_align);
 	  }
@@ -253,11 +254,11 @@ fprintf(stderr, "    VAR %d %s: %ld\n", ii, (*vpp)->name->cp, (long)index);
 	/* only (re)calculate begin_rec if there is not sufficient
 	   space at end of non-record variables or if start of record
 	   variables is not aligned as requested by r_align */
-	if (ncp->begin_rec < index + v_minfree ||
+	if (ncp->begin_rec < index + (off_t)v_minfree ||
 	    ncp->begin_rec != D_RNDUP(ncp->begin_rec, r_align) )
 	{
 	  ncp->begin_rec = D_RNDUP(index, r_align);
-	  if(ncp->begin_rec < index + v_minfree)
+	  if(ncp->begin_rec < index + (off_t)v_minfree)
 	  {
 	    ncp->begin_rec = D_RNDUP(index + (off_t)v_minfree, r_align);
 	  }
@@ -524,8 +525,8 @@ fill_added_recs(NC3_INFO *gnu, NC3_INFO *old)
 {
 	NC_var ** const gnu_varpp = (NC_var **)gnu->vars.value;
 
-	const int old_nrecs = (int) NC_get_numrecs(old);
-	int recno = 0;
+	const size_t old_nrecs = NC_get_numrecs(old);
+	size_t recno = 0;
 	NC_var **vpp = gnu_varpp;
 	NC_var *const *const end = &vpp[gnu->vars.nelems];
 	int numrecvars = 0;
@@ -554,7 +555,7 @@ fill_added_recs(NC3_INFO *gnu, NC3_INFO *old)
 			    }
 			/* else */
 			{
-			    size_t varsize = numrecvars == 1 ? gnu->recsize :  gnu_varp->len;
+			    long long varsize = numrecvars == 1 ? gnu->recsize :  gnu_varp->len;
 			    const int status = fill_NC_var(gnu, gnu_varp, varsize, recno);
 			    if(status != NC_NOERR)
 				return status;
@@ -629,8 +630,8 @@ move_recs_r(NC3_INFO *gnu, NC3_INFO *old)
 
 		/* else, a pre-existing variable */
 		old_varp = *(old_varpp + varid);
-		gnu_off = gnu_varp->begin + (off_t)(gnu->recsize * recno);
-		old_off = old_varp->begin + (off_t)(old->recsize * recno);
+		gnu_off = gnu_varp->begin + (off_t)(gnu->recsize * (size_t)recno);
+		old_off = old_varp->begin + (off_t)(old->recsize * (size_t)recno);
 
 		if(gnu_off == old_off)
 			continue; 	/* nothing to do */
@@ -955,7 +956,7 @@ NC_calcsize(const NC3_INFO *ncp, off_t *calcsizep)
 
 	if(ncp->vars.nelems == 0) { /* no non-record variables and
 				       no record variables */
-	    *calcsizep = ncp->xsz; /* size of header */
+	    *calcsizep = (off_t)ncp->xsz; /* size of header */
 	    return NC_NOERR;
 	}
 
@@ -976,16 +977,15 @@ NC_calcsize(const NC3_INFO *ncp, off_t *calcsizep)
 	    assert(last_fix != NULL);
 	    varsize = last_fix->len;
 	    if(last_fix->len == X_UINT_MAX) { /* huge last fixed var */
-		int i;
 		varsize = 1;
-  	        for(i = 0; i < last_fix->ndims; i++ ) {
-                varsize *= (last_fix->shape ? last_fix->shape[i] : 1);
-		    }
+		for(size_t i = 0; i < last_fix->ndims; i++ ) {
+		    varsize *= (last_fix->shape ? last_fix->shape[i] : 1);
+		}
 	    }
 	    *calcsizep = last_fix->begin + varsize;
 	    /*last_var = last_fix;*/
 	} else {       /* we have at least one record variable */
-	    *calcsizep = ncp->begin_rec + ncp->numrecs * ncp->recsize;
+	    *calcsizep = ncp->begin_rec + (off_t)(ncp->numrecs * ncp->recsize);
 	}
 
 	return NC_NOERR;
@@ -1021,7 +1021,7 @@ NC3_create(const char *path, int ioflags, size_t initialsz, int basepe,
 {
 	int status = NC_NOERR;
 	void *xp = NULL;
-	int sizeof_off_t = 0;
+	size_t sizeof_off_t = 0;
         NC *nc;
 	NC3_INFO* nc3 = NULL;
 
diff --git a/libsrc/posixio.c b/libsrc/posixio.c
index d803ca86cc..68d320782d 100644
--- a/libsrc/posixio.c
+++ b/libsrc/posixio.c
@@ -215,7 +215,7 @@ fgrow(const int fd, const off_t len)
 	    const off_t pos = lseek(fd, 0, SEEK_CUR);
 	    if(pos < 0)
 		return errno;
-	    if (lseek(fd, len-sizeof(dumb), SEEK_SET) < 0)
+	    if (lseek(fd, len-(off_t)sizeof(dumb), SEEK_SET) < 0)
 		return errno;
 	    if(write(fd, &dumb, sizeof(dumb)) < 0)
 		return errno;
@@ -313,11 +313,11 @@ px_pgout(ncio *const nciop,
 	    if(partial == nextent)
 		break;
 	    nvp += partial;
-	    nextent -= partial;
+	    nextent -= (size_t)partial;
 	}
 	if(partial == -1)
 	    return errno;
-	*posp += extent;
+	*posp += (off_t)extent;
 
 	return NC_NOERR;
 }
@@ -390,13 +390,13 @@ px_pgin(ncio *const nciop,
       if( nread == -1 || (status != EINTR && status != NC_NOERR))
         return status;
       /* else it's okay we read less than asked for */
-      (void) memset((char *)vp + nread, 0, (ssize_t)extent - nread);
+      (void) memset((char *)vp + nread, 0, (size_t)((ssize_t)extent - nread));
     }
 
-    *nreadp = nread;
-	*posp += nread;
+    *nreadp = (size_t)nread;
+    *posp += nread;
 
-	return NC_NOERR;
+    return NC_NOERR;
 }
 
 /* This struct is for POSIX systems, with NC_SHARE not in effect. If
@@ -533,8 +533,8 @@ px_get(ncio *const nciop, ncio_px *const pxp,
 	int status = NC_NOERR;
 
 	const off_t blkoffset = _RNDDOWN(offset, (off_t)pxp->blksz);
-	off_t diff = (size_t)(offset - blkoffset);
-	off_t blkextent = _RNDUP(diff + extent, pxp->blksz);
+	off_t diff = offset - blkoffset;
+	size_t blkextent = _RNDUP((size_t)diff + extent, pxp->blksz);
 
 	if(!(extent != 0 && extent < X_INT_MAX && offset >= 0)) /* sanity check */
 	    return NC_ENOTNC;
@@ -588,7 +588,7 @@ px_get(ncio *const nciop, ncio_px *const pxp,
 		if(blkextent == pxp->blksz)
 		{
 			/* all in upper half, no fault needed */
-			diff += pxp->blksz;
+			diff += (off_t)pxp->blksz;
 			goto done;
 		}
 		/* else */
@@ -730,11 +730,11 @@ px_get(ncio *const nciop, ncio_px *const pxp,
 		 &pxp->pos);
 	if(status != NC_NOERR)
 		return status;
-	 pxp->bf_offset = blkoffset;
-	 pxp->bf_extent = blkextent;
+        pxp->bf_offset = blkoffset;
+        pxp->bf_extent = blkextent;
 
 done:
-	extent += diff;
+	extent += (size_t)diff;
 	if(pxp->bf_cnt < extent)
 		pxp->bf_cnt = extent;
 	assert(pxp->bf_cnt <= pxp->bf_extent);
@@ -913,13 +913,13 @@ fprintf(stderr, "ncio_px_move %ld %ld %ld %ld %ld\n",
 
 if(to > from)
 {
-		off_t frm = from + nbytes;
-		off_t toh = to + nbytes;
+		off_t frm = from + (off_t)nbytes;
+		off_t toh = to + (off_t)nbytes;
 		for(;;)
 		{
 			size_t loopextent = MIN(remaining, pxp->blksz);
-			frm -= loopextent;
-			toh -= loopextent;
+			frm -= (off_t)loopextent;
+                        toh -= (off_t)loopextent;
 
 			status = px_double_buffer(nciop, toh, frm,
 				 	loopextent, rflags) ;
@@ -945,8 +945,8 @@ else
 
 			if(remaining == 0)
 				break; /* normal loop exit */
-			to += loopextent;
-			from += loopextent;
+			to += (off_t)loopextent;
+                        from += (off_t)loopextent;
 		}
 }
 		return NC_NOERR;
diff --git a/libsrc/putget.m4 b/libsrc/putget.m4
index 9a0aca8a27..c8d713880e 100644
--- a/libsrc/putget.m4
+++ b/libsrc/putget.m4
@@ -245,7 +245,7 @@ fill_NC_var(NC3_INFO* ncp, const NC_var *varp, long long varsize, size_t recno)
 	offset = varp->begin;
 	if(IS_RECVAR(varp))
 	{
-		offset += (off_t)ncp->recsize * recno;
+		offset += (off_t)(ncp->recsize * recno);
 	}
 
 	assert(remaining > 0);
@@ -613,10 +613,10 @@ NC_varoffset(const NC3_INFO* ncp, const NC_var *varp, const size_t *coord)
 		for(; up < end; up++, ip++)
 			lcoord += (off_t)(*up) * (off_t)(*ip);
 
-		lcoord *= varp->xsz;
+		lcoord *= (off_t)varp->xsz;
 
 		if(IS_RECVAR(varp))
-			lcoord += (off_t)(*coord) * ncp->recsize;
+			lcoord += (off_t)(*coord * ncp->recsize);
 
 		lcoord += varp->begin;
 		return lcoord;
@@ -1846,7 +1846,7 @@ NC3_get_vara(int ncid, int varid,
         return status;
 
     /* Get the size of the memtype */
-    memtypelen = nctypelen(memtype);
+    memtypelen = (size_t)nctypelen(memtype);
 
     if(varp->ndims == 0) /* scalar variable */
     {
@@ -1880,7 +1880,7 @@ NC3_get_vara(int ncid, int varid,
     { /* inline */
     ALLOC_ONSTACK(coord, size_t, varp->ndims);
     ALLOC_ONSTACK(upper, size_t, varp->ndims);
-    const size_t index = ii;
+    const size_t index = (size_t)ii;
 
     /* copy in starting indices */
     (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
@@ -1956,7 +1956,7 @@ NC3_put_vara(int ncid, int varid,
         return NC_ECHAR;
 
     /* Get the size of the memtype */
-    memtypelen = nctypelen(memtype);
+    memtypelen = (size_t)nctypelen(memtype);
 
     /* If edges is NULL, then this was called from nc_get_var() */
     if(edges == NULL && varp->ndims > 0) {
@@ -2013,7 +2013,7 @@ NC3_put_vara(int ncid, int varid,
     { /* inline */
     ALLOC_ONSTACK(coord, size_t, varp->ndims);
     ALLOC_ONSTACK(upper, size_t, varp->ndims);
-    const size_t index = ii;
+    const size_t index = (size_t)ii;
 
     /* copy in starting indices */
     (void) memcpy(coord, start, varp->ndims * sizeof(size_t));
diff --git a/libsrc/v1hpg.c b/libsrc/v1hpg.c
index d1c6684469..1210488acd 100644
--- a/libsrc/v1hpg.c
+++ b/libsrc/v1hpg.c
@@ -561,8 +561,8 @@ v1h_get_NC_dimarray(v1hs *gsp, NC_dimarray *ncap)
 				return status;
 			}
 			{
-			  int dimid = (size_t)(dpp - ncap->value);
-			  NC_hashmapadd(ncap->hashmap, (uintptr_t)dimid, (*dpp)->name->cp,strlen((*dpp)->name->cp));
+			  uintptr_t dimid = (uintptr_t)(dpp - ncap->value);
+			  NC_hashmapadd(ncap->hashmap, dimid, (*dpp)->name->cp, strlen((*dpp)->name->cp));
 			}
 		}
 	}
@@ -601,7 +601,7 @@ ncx_len_NC_attr(const NC_attr *attrp, int version)
 
 /*----< ncmpix_len_nctype() >------------------------------------------------*/
 /* return the length of external data type */
-static int
+static size_t
 ncmpix_len_nctype(nc_type type) {
     switch(type) {
         case NC_BYTE:
@@ -1212,8 +1212,8 @@ v1h_get_NC_vararray(v1hs *gsp, NC_vararray *ncap)
 				return status;
 			}
 			{
-			  int varid = (size_t)(vpp - ncap->value);
-			  NC_hashmapadd(ncap->hashmap, (uintptr_t)varid, (*vpp)->name->cp,strlen((*vpp)->name->cp));
+			  uintptr_t varid = (uintptr_t)(vpp - ncap->value);
+			  NC_hashmapadd(ncap->hashmap, varid, (*vpp)->name->cp, strlen((*vpp)->name->cp));
 			}
 		}
 	}
diff --git a/libsrc/var.c b/libsrc/var.c
index c8cd64dcd6..6b636e1cdb 100644
--- a/libsrc/var.c
+++ b/libsrc/var.c
@@ -13,6 +13,7 @@
 #include <string.h>
 #include <assert.h>
 #include <limits.h>
+#include <sys/types.h>
 #include "ncx.h"
 #include "rnd.h"
 #include "ncutf8.h"
@@ -133,9 +134,9 @@ new_NC_var(const char *uname, nc_type type,
 	int stat;
 	char* name;
 
-        stat = nc_utf8_normalize((const unsigned char *)uname,(unsigned char **)&name);
-        if(stat != NC_NOERR)
-	    return NULL;
+    stat = nc_utf8_normalize((const unsigned char *)uname,(unsigned char **)&name);
+    if(stat != NC_NOERR)
+      return NULL;
 	strp = new_NC_string(strlen(name), name);
 	free(name);
 	if(strp == NULL)
@@ -150,8 +151,8 @@ new_NC_var(const char *uname, nc_type type,
 
 	varp->type = type;
 
-	if( ndims != 0 && dimids != NULL)
-	  (void) memcpy(varp->dimids, dimids, ndims * sizeof(int));
+    if( ndims != 0 && dimids != NULL)
+      (void) memcpy(varp->dimids, dimids, ndims * sizeof(int));
     else
       varp->dimids=NULL;
 
@@ -478,7 +479,7 @@ NC_var_shape(NC_var *varp, const NC_dimarray *dims)
 		{
           if( ((off_t)(*shp)) <= OFF_T_MAX / product )
 			{
-              product *= (*shp > 0 ? *shp : 1);
+              product *= (*shp > 0 ? (off_t)*shp : 1);
 			} else
 			{
               product = OFF_T_MAX ;
@@ -497,7 +498,7 @@ out :
      * offset of this variable is less than 2GiB.
      * This will be checked in NC_check_vlens() during NC_endef()
      */
-    varp->len = product * varp->xsz;
+    varp->len = product * (off_t)varp->xsz;
     if (varp->len % 4 > 0)
         varp->len += 4 - varp->len % 4; /* round up */
 
@@ -518,7 +519,7 @@ out :
 int
 NC_check_vlen(NC_var *varp, long long vlen_max) {
     size_t ii;
-    long long prod=varp->xsz;	/* product of xsz and dimensions so far */
+    long long prod = (long long)varp->xsz;	/* product of xsz and dimensions so far */
 
     assert(varp != NULL);
     for(ii = IS_RECVAR(varp) ? 1 : 0; ii < varp->ndims; ii++) {
@@ -527,7 +528,7 @@ NC_check_vlen(NC_var *varp, long long vlen_max) {
       if ((long long)varp->shape[ii] > vlen_max / prod) {
         return 0;		/* size in bytes won't fit in a 32-bit int */
       }
-      prod *= varp->shape[ii];
+      prod *= (long long)varp->shape[ii];
     }
     return 1;			/* OK */
 }
@@ -610,7 +611,7 @@ NC3_def_var( int ncid, const char *name, nc_type type,
 		return NC_ENAMEINUSE;
 	}
 
-	varp = new_NC_var(name, type, ndims, dimids);
+	varp = new_NC_var(name, type, (size_t)ndims, dimids);
 	if(varp == NULL)
 		return NC_ENOMEM;