#1
nsdbtest/nsdbtest.c:184: error: Null Dereference
  pointer `null` is dereferenced by call to `Ns_SetPutSz()` at line 184, column 11.

nsdbtest/nsdbtest.c:181:1: start of procedure BindRow()
179.  */
180. 
181. static Ns_Set *
     ^
182. BindRow(Ns_DbHandle *handle)
183. {

nsdbtest/nsdbtest.c:184:11: 
182. BindRow(Ns_DbHandle *handle)
183. {
184.     (void)Ns_SetPutSz(handle->row, "column1", 7, NULL, 0);
               ^
185.     handle->fetchingRows = NS_FALSE;
186. 

nsd/set.c:422:1: start of procedure Ns_SetPutSz()
  420.  */
  421. 
  422. size_t
       ^
  423. Ns_SetPutSz(Ns_Set *set, const char *keyString, ssize_t keyLength, const char *valueString, ssize_t valueLength)
  424. {

nsd/set.c:427:5: 
  425.     size_t idx;
  426. 
  427.     NS_NONNULL_ASSERT(set != NULL);
           ^
  428.     NS_NONNULL_ASSERT(keyString != NULL);
  429. 

nsd/set.c:428:5: 
  426. 
  427.     NS_NONNULL_ASSERT(set != NULL);
  428.     NS_NONNULL_ASSERT(keyString != NULL);
           ^
  429. 
  430.     assert(set->size <=  set->maxSize);

nsd/set.c:430:5: 
  428.     NS_NONNULL_ASSERT(keyString != NULL);
  429. 
  430.     assert(set->size <=  set->maxSize);
           ^
  431.     idx = set->size;
  432.     set->size++;

nsd/set.c:431:5: 
  429. 
  430.     assert(set->size <=  set->maxSize);
  431.     idx = set->size;
           ^
  432.     set->size++;
  433. 

nsd/set.c:432:5: 
  430.     assert(set->size <=  set->maxSize);
  431.     idx = set->size;
  432.     set->size++;
           ^
  433. 
  434.     if (set->size >= set->maxSize) {

nsd/set.c:434:9: Taking false branch
  432.     set->size++;
  433. 
  434.     if (set->size >= set->maxSize) {
               ^
  435.         size_t oldSize = set->size;
  436. 

nsd/set.c:448:5: 
  446.     set->fields[idx].value = AppendData(set, idx, valueString, valueLength);
  447. #else
  448.     set->fields[idx].name = ns_strncopy(keyString, keyLength);
           ^
  449.     set->fields[idx].value = ns_strncopy(valueString, valueLength);
  450. #endif

nsthread/memory.c:154:1: start of procedure ns_strncopy()
    152. }
    153. 
    154. char *
         ^
    155. ns_strncopy(const char *old, ssize_t size)
    156. {

nsthread/memory.c:157:5: 
    155. ns_strncopy(const char *old, ssize_t size)
    156. {
    157.     char *new = NULL;
             ^
    158. 
    159.     if (likely(old != NULL)) {

nsthread/memory.c:159:9: Condition is true
    157.     char *new = NULL;
    158. 
    159.     if (likely(old != NULL)) {
                 ^
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;

nsthread/memory.c:159:9: Taking true branch
    157.     char *new = NULL;
    158. 
    159.     if (likely(old != NULL)) {
                 ^
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;

nsthread/memory.c:160:9: 
    158. 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
                 ^
    161.         new_size ++;
    162.         new = ns_malloc(new_size);

nsthread/memory.c:160:27: Condition is false
    158. 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
                                   ^
    161.         new_size ++;
    162.         new = ns_malloc(new_size);

nsthread/memory.c:160:27: Condition is false
    158. 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
                                   ^
    161.         new_size ++;
    162.         new = ns_malloc(new_size);

nsthread/memory.c:161:9: 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;
                 ^
    162.         new = ns_malloc(new_size);
    163.         if (new != NULL) {

nsthread/memory.c:162:9: 
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;
    162.         new = ns_malloc(new_size);
                 ^
    163.         if (new != NULL) {
    164.             memcpy(new, old, new_size);

nsthread/memory.c:72:1: start of procedure ns_malloc()
      70.     return result;
      71. }
      72. void *ns_malloc(size_t size) {
          ^
      73.     void *result;
      74. #ifdef NS_VERBOSE_MALLOC

nsthread/memory.c:83:5: 
      81.      * in general, that a malloc() result of NULL means out of memory.
      82.      */
      83.     result = malloc(size);
              ^
      84.     /*if (size == 0u) {
      85.         fprintf(stderr, "ZERO ns_malloc size=%lu ptr %p\n", size, result);

nsthread/memory.c:87:9: Condition is false
      85.         fprintf(stderr, "ZERO ns_malloc size=%lu ptr %p\n", size, result);
      86.         }*/
      87.     if (unlikely(result == NULL && size > 0u)) {
                  ^
      88.         fprintf(stderr, "Fatal: failed to allocate %" PRIuz " bytes.\n", size);
      89.         abort();

nsthread/memory.c:87:9: Taking false branch
      85.         fprintf(stderr, "ZERO ns_malloc size=%lu ptr %p\n", size, result);
      86.         }*/
      87.     if (unlikely(result == NULL && size > 0u)) {
                  ^
      88.         fprintf(stderr, "Fatal: failed to allocate %" PRIuz " bytes.\n", size);
      89.         abort();

nsthread/memory.c:91:5: 
      89.         abort();
      90.     }
      91.     return result;
              ^
      92. }
      93. void ns_free(void *ptr) {

nsthread/memory.c:92:1: return from a call to ns_malloc
      90.     }
      91.     return result;
      92. }
          ^
      93. void ns_free(void *ptr) {
      94.     free(ptr);

nsthread/memory.c:163:13: Taking true branch
    161.         new_size ++;
    162.         new = ns_malloc(new_size);
    163.         if (new != NULL) {
                     ^
    164.             memcpy(new, old, new_size);
    165.         } else {

nsthread/memory.c:164:13: 
    162.         new = ns_malloc(new_size);
    163.         if (new != NULL) {
    164.             memcpy(new, old, new_size);
                     ^
    165.         } else {
    166. #if defined(ENOMEM)

nsthread/memory.c:171:5: 
    169.         }
    170.     }
    171.     return new;
             ^
    172. }
    173. 

nsthread/memory.c:172:1: return from a call to ns_strncopy
    170.     }
    171.     return new;
    172. }
         ^
    173. 
    174. char *

nsd/set.c:449:5: 
  447. #else
  448.     set->fields[idx].name = ns_strncopy(keyString, keyLength);
  449.     set->fields[idx].value = ns_strncopy(valueString, valueLength);
           ^
  450. #endif
  451.     return idx;

nsthread/memory.c:154:1: start of procedure ns_strncopy()
    152. }
    153. 
    154. char *
         ^
    155. ns_strncopy(const char *old, ssize_t size)
    156. {

nsthread/memory.c:157:5: 
    155. ns_strncopy(const char *old, ssize_t size)
    156. {
    157.     char *new = NULL;
             ^
    158. 
    159.     if (likely(old != NULL)) {

nsthread/memory.c:159:9: Condition is true
    157.     char *new = NULL;
    158. 
    159.     if (likely(old != NULL)) {
                 ^
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;

nsthread/memory.c:159:9: Taking true branch
    157.     char *new = NULL;
    158. 
    159.     if (likely(old != NULL)) {
                 ^
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;

nsthread/memory.c:160:9: 
    158. 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
                 ^
    161.         new_size ++;
    162.         new = ns_malloc(new_size);

nsthread/memory.c:160:27: Condition is false
    158. 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
                                   ^
    161.         new_size ++;
    162.         new = ns_malloc(new_size);

nsthread/memory.c:160:27: Condition is false
    158. 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
                                   ^
    161.         new_size ++;
    162.         new = ns_malloc(new_size);

nsthread/memory.c:161:9: 
    159.     if (likely(old != NULL)) {
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;
                 ^
    162.         new = ns_malloc(new_size);
    163.         if (new != NULL) {

nsthread/memory.c:162:9: 
    160.         size_t new_size = likely(size > 0) ? (size_t)size : strlen(old);
    161.         new_size ++;
    162.         new = ns_malloc(new_size);
                 ^
    163.         if (new != NULL) {
    164.             memcpy(new, old, new_size);

nsthread/memory.c:72:1: start of procedure ns_malloc()
      70.     return result;
      71. }
      72. void *ns_malloc(size_t size) {
          ^
      73.     void *result;
      74. #ifdef NS_VERBOSE_MALLOC

nsthread/memory.c:83:5: 
      81.      * in general, that a malloc() result of NULL means out of memory.
      82.      */
      83.     result = malloc(size);
              ^
      84.     /*if (size == 0u) {
      85.         fprintf(stderr, "ZERO ns_malloc size=%lu ptr %p\n", size, result);

nsthread/memory.c:87:9: Condition is false
      85.         fprintf(stderr, "ZERO ns_malloc size=%lu ptr %p\n", size, result);
      86.         }*/
      87.     if (unlikely(result == NULL && size > 0u)) {
                  ^
      88.         fprintf(stderr, "Fatal: failed to allocate %" PRIuz " bytes.\n", size);
      89.         abort();

nsthread/memory.c:87:9: Taking false branch
      85.         fprintf(stderr, "ZERO ns_malloc size=%lu ptr %p\n", size, result);
      86.         }*/
      87.     if (unlikely(result == NULL && size > 0u)) {
                  ^
      88.         fprintf(stderr, "Fatal: failed to allocate %" PRIuz " bytes.\n", size);
      89.         abort();

nsthread/memory.c:91:5: 
      89.         abort();
      90.     }
      91.     return result;
              ^
      92. }
      93. void ns_free(void *ptr) {

nsthread/memory.c:92:1: return from a call to ns_malloc
      90.     }
      91.     return result;
      92. }
          ^
      93. void ns_free(void *ptr) {
      94.     free(ptr);

nsthread/memory.c:163:13: Taking true branch
    161.         new_size ++;
    162.         new = ns_malloc(new_size);
    163.         if (new != NULL) {
                     ^
    164.             memcpy(new, old, new_size);
    165.         } else {

nsthread/memory.c:164:13: 
    162.         new = ns_malloc(new_size);
    163.         if (new != NULL) {
    164.             memcpy(new, old, new_size);
                     ^
    165.         } else {
    166. #if defined(ENOMEM)

nsthread/memory.c:171:5: 
    169.         }
    170.     }
    171.     return new;
             ^
    172. }
    173. 

nsthread/memory.c:172:1: return from a call to ns_strncopy
    170.     }
    171.     return new;
    172. }
         ^
    173. 
    174. char *

nsd/set.c:451:5: 
  449.     set->fields[idx].value = ns_strncopy(valueString, valueLength);
  450. #endif
  451.     return idx;
           ^
  452. }
  453. 

nsd/set.c:452:1: return from a call to Ns_SetPutSz
  450. #endif
  451.     return idx;
  452. }
       ^
  453. 
  454. size_t