#4
nsd/tclcache.c:377: error: Null Dereference
  pointer `cPtr` last assigned on line 313 could be null and is dereferenced at line 377, column 26.

nsd/tclcache.c:307:1: start of procedure NsTclCacheConfigureObjCmd()
305.  */
306. 
307. int
     ^
308. NsTclCacheConfigureObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
309. {

nsd/tclcache.c:310:5: 
308. NsTclCacheConfigureObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const* objv)
309. {
310.     int         result = TCL_OK, nargs = 0;
         ^
311.     Tcl_WideInt maxSize = 0, maxEntry = 0;
312.     Ns_Time    *timeoutPtr = NULL, *expPtr = NULL;

nsd/tclcache.c:311:5: 
309. {
310.     int         result = TCL_OK, nargs = 0;
311.     Tcl_WideInt maxSize = 0, maxEntry = 0;
         ^
312.     Ns_Time    *timeoutPtr = NULL, *expPtr = NULL;
313.     TclCache   *cPtr = NULL;

nsd/tclcache.c:312:5: 
310.     int         result = TCL_OK, nargs = 0;
311.     Tcl_WideInt maxSize = 0, maxEntry = 0;
312.     Ns_Time    *timeoutPtr = NULL, *expPtr = NULL;
         ^
313.     TclCache   *cPtr = NULL;
314.     Ns_ObjvSpec opts[] = {

nsd/tclcache.c:313:5: 
311.     Tcl_WideInt maxSize = 0, maxEntry = 0;
312.     Ns_Time    *timeoutPtr = NULL, *expPtr = NULL;
313.     TclCache   *cPtr = NULL;
         ^
314.     Ns_ObjvSpec opts[] = {
315.         {"-timeout",  Ns_ObjvTime,    &timeoutPtr, NULL},

nsd/tclcache.c:314:5: 
312.     Ns_Time    *timeoutPtr = NULL, *expPtr = NULL;
313.     TclCache   *cPtr = NULL;
314.     Ns_ObjvSpec opts[] = {
         ^
315.         {"-timeout",  Ns_ObjvTime,    &timeoutPtr, NULL},
316.         {"-expires",  Ns_ObjvTime,    &expPtr,     NULL},

nsd/tclcache.c:321:5: 
319.         {NULL, NULL,  NULL, NULL}
320.     };
321.     Ns_ObjvSpec args[] = {
         ^
322.         {"cache",     ObjvCache,     &cPtr,   clientData},
323.         {"?args",     Ns_ObjvArgs,   &nargs,  NULL},

nsd/tclcache.c:331:9: Taking false branch
329.      * argument vector in two parts.
330.      */
331.     if (Ns_ParseObjv(NULL, args, interp, 1, objc, objv) != NS_OK) {
             ^
332.         result = TCL_ERROR;
333. 

nsd/tclcache.c:334:16: Taking false branch
332.         result = TCL_ERROR;
333. 
334.     } else if (objc > 2 && Ns_ParseObjv(opts, NULL, interp, 2, objc, objv) != NS_OK) {
                    ^
335.         result = TCL_ERROR;
336. 

nsd/tclcache.c:337:16: Taking false branch
335.         result = TCL_ERROR;
336. 
337.     } else if (maxSize < 0) {
                    ^
338.         Ns_TclPrintfResult(interp, "maxsize must be a positive number");
339.         result = TCL_ERROR;

nsd/tclcache.c:341:16: Taking false branch
339.         result = TCL_ERROR;
340. 
341.     } else if (maxEntry < 0) {
                    ^
342.         Ns_TclPrintfResult(interp, "maxEntry must be a positive number");
343.         result = TCL_ERROR;

nsd/tclcache.c:345:16: Taking false branch
343.         result = TCL_ERROR;
344. 
345.     } else if (objc > 2) {
                    ^
346.         const NsInterp *itPtr = clientData;
347.         NsServer       *servPtr = itPtr->servPtr;

nsd/tclcache.c:366:16: Taking true branch
364.         Ns_RWLockUnlock(&servPtr->tcl.cachelock);
365. 
366.     } else if (objc == 2) {
                    ^
367.         const NsInterp *itPtr = clientData;
368.         NsServer       *servPtr = itPtr->servPtr;

nsd/tclcache.c:367:9: 
365. 
366.     } else if (objc == 2) {
367.         const NsInterp *itPtr = clientData;
             ^
368.         NsServer       *servPtr = itPtr->servPtr;
369.         Tcl_Obj        *resultObj = Tcl_NewListObj(0, NULL);

nsd/tclcache.c:368:9: 
366.     } else if (objc == 2) {
367.         const NsInterp *itPtr = clientData;
368.         NsServer       *servPtr = itPtr->servPtr;
             ^
369.         Tcl_Obj        *resultObj = Tcl_NewListObj(0, NULL);
370.         Tcl_DString     ds;

nsd/tclcache.c:369:9: Skipping Tcl_NewListObj(): method has no implementation
367.         const NsInterp *itPtr = clientData;
368.         NsServer       *servPtr = itPtr->servPtr;
369.         Tcl_Obj        *resultObj = Tcl_NewListObj(0, NULL);
             ^
370.         Tcl_DString     ds;
371. 

nsd/tclcache.c:372:9: 
370.         Tcl_DString     ds;
371. 
372.         assert(cPtr != NULL);
             ^
373. 
374.         Tcl_DStringInit(&ds);

nsd/tclcache.c:374:9: Skipping Tcl_DStringInit(): method has no implementation
372.         assert(cPtr != NULL);
373. 
374.         Tcl_DStringInit(&ds);
             ^
375. 
376.         Ns_RWLockRdLock(&servPtr->tcl.cachelock);

nsd/tclcache.c:376:9: 
374.         Tcl_DStringInit(&ds);
375. 
376.         Ns_RWLockRdLock(&servPtr->tcl.cachelock);
             ^
377.         maxSize  = (long)cPtr->maxSize;
378.         maxEntry = (long)cPtr->maxEntry;

nsthread/rwlock.c:333:1: start of procedure Ns_RWLockRdLock()
  331.  */
  332. 
  333. void
       ^
  334. Ns_RWLockRdLock(Ns_RWLock *rwPtr)
  335. {

nsthread/rwlock.c:340:5: 
  338.     bool    busy;
  339. 
  340.     NS_NONNULL_ASSERT(rwPtr != NULL);
           ^
  341. 
  342.     lockPtr = GetRwLock(rwPtr);

nsthread/rwlock.c:342:5: 
  340.     NS_NONNULL_ASSERT(rwPtr != NULL);
  341. 
  342.     lockPtr = GetRwLock(rwPtr);
           ^
  343. 
  344.     err = pthread_rwlock_tryrdlock(&lockPtr->rwlock);

nsthread/rwlock.c:496:1: start of procedure GetRwLock()
    494.  */
    495. 
    496. static RwLock *
         ^
    497. GetRwLock(Ns_RWLock *rwPtr)
    498. {

nsthread/rwlock.c:499:5: 
    497. GetRwLock(Ns_RWLock *rwPtr)
    498. {
    499.     NS_NONNULL_ASSERT(rwPtr != NULL);
             ^
    500. 
    501.     if (*rwPtr == NULL) {

nsthread/rwlock.c:501:9: Taking true branch
    499.     NS_NONNULL_ASSERT(rwPtr != NULL);
    500. 
    501.     if (*rwPtr == NULL) {
                 ^
    502.         Ns_MasterLock();
    503.         if (*rwPtr == NULL) {

nsthread/rwlock.c:502:9: 
    500. 
    501.     if (*rwPtr == NULL) {
    502.         Ns_MasterLock();
                 ^
    503.         if (*rwPtr == NULL) {
    504.             Ns_RWLockInit(rwPtr);

nsthread/master.c:65:1: start of procedure Ns_MasterLock()
      63. }
      64. 
      65. void
          ^
      66. Ns_MasterLock(void)
      67. {

nsthread/master.c:68:9: Taking false branch
      66. Ns_MasterLock(void)
      67. {
      68.     if (initialized) {
                  ^
      69.         Ns_CsEnter(&master);
      70.     }

nsthread/master.c:68:5: 
      66. Ns_MasterLock(void)
      67. {
      68.     if (initialized) {
              ^
      69.         Ns_CsEnter(&master);
      70.     }

nsthread/master.c:71:1: return from a call to Ns_MasterLock
      69.         Ns_CsEnter(&master);
      70.     }
      71. }
          ^
      72. 
      73. void

nsthread/rwlock.c:503:13: Taking true branch
    501.     if (*rwPtr == NULL) {
    502.         Ns_MasterLock();
    503.         if (*rwPtr == NULL) {
                     ^
    504.             Ns_RWLockInit(rwPtr);
    505.         }

nsthread/rwlock.c:504:13: 
    502.         Ns_MasterLock();
    503.         if (*rwPtr == NULL) {
    504.             Ns_RWLockInit(rwPtr);
                     ^
    505.         }
    506.         Ns_MasterUnlock();

nsthread/rwlock.c:178:1: start of procedure Ns_RWLockInit()
      176.  */
      177. 
      178. void
           ^
      179. Ns_RWLockInit(Ns_RWLock *rwPtr)
      180. {

nsthread/rwlock.c:182:5: 
      180. {
      181.     RwLock          *lockPtr;
      182.     static uintptr_t nextid = 0;
               ^
      183. 
      184.     NS_NONNULL_ASSERT(rwPtr != NULL);

nsthread/rwlock.c:184:5: 
      182.     static uintptr_t nextid = 0;
      183. 
      184.     NS_NONNULL_ASSERT(rwPtr != NULL);
               ^
      185. 
      186.     lockPtr = ns_calloc(1u, sizeof(RwLock));

nsthread/rwlock.c:186:5: 
      184.     NS_NONNULL_ASSERT(rwPtr != NULL);
      185. 
      186.     lockPtr = ns_calloc(1u, sizeof(RwLock));
               ^
      187. 
      188.     Ns_MasterLock();

nsthread/memory.c:96:1: start of procedure ns_calloc()
        94.     free(ptr);
        95. }
        96. void *ns_calloc(size_t num, size_t esize) {
            ^
        97.     void *result;
        98. 

nsthread/memory.c:99:5: 
         97.     void *result;
         98. 
         99.     assert(num > 0u);
                 ^
        100.     assert(esize > 0u);
        101. 

nsthread/memory.c:100:5: 
         98. 
         99.     assert(num > 0u);
        100.     assert(esize > 0u);
                 ^
        101. 
        102. #ifdef NS_VERBOSE_MALLOC

nsthread/memory.c:106:5: 
        104. #endif
        105. 
        106.     result = calloc(num, esize);
                 ^
        107.     if (result == NULL) {
        108.         fprintf(stderr, "Fatal: failed to allocate %" PRIuz " bytes.\n", num * esize);

nsthread/memory.c:107:9: Taking false branch
        105. 
        106.     result = calloc(num, esize);
        107.     if (result == NULL) {
                     ^
        108.         fprintf(stderr, "Fatal: failed to allocate %" PRIuz " bytes.\n", num * esize);
        109.         abort();

nsthread/memory.c:111:5: 
        109.         abort();
        110.     }
        111.     return result;
                 ^
        112. }
        113. #else

nsthread/memory.c:112:1: return from a call to ns_calloc
        110.     }
        111.     return result;
        112. }
             ^
        113. #else
        114. void *

nsthread/rwlock.c:188:5: 
      186.     lockPtr = ns_calloc(1u, sizeof(RwLock));
      187. 
      188.     Ns_MasterLock();
               ^
      189.     lockPtr->nextPtr = firstRwlockPtr;
      190.     firstRwlockPtr = lockPtr;

nsthread/master.c:65:1: start of procedure Ns_MasterLock()
        63. }
        64. 
        65. void
            ^
        66. Ns_MasterLock(void)
        67. {

nsthread/master.c:68:9: Taking false branch
        66. Ns_MasterLock(void)
        67. {
        68.     if (initialized) {
                    ^
        69.         Ns_CsEnter(&master);
        70.     }

nsthread/master.c:68:5: 
        66. Ns_MasterLock(void)
        67. {
        68.     if (initialized) {
                ^
        69.         Ns_CsEnter(&master);
        70.     }

nsthread/master.c:71:1: return from a call to Ns_MasterLock
        69.         Ns_CsEnter(&master);
        70.     }
        71. }
            ^
        72. 
        73. void

nsthread/rwlock.c:189:5: 
      187. 
      188.     Ns_MasterLock();
      189.     lockPtr->nextPtr = firstRwlockPtr;
               ^
      190.     firstRwlockPtr = lockPtr;
      191.     lockPtr->id = nextid++;

nsthread/rwlock.c:190:5: 
      188.     Ns_MasterLock();
      189.     lockPtr->nextPtr = firstRwlockPtr;
      190.     firstRwlockPtr = lockPtr;
               ^
      191.     lockPtr->id = nextid++;
      192.     lockPtr->name[0] = 'r';

nsthread/rwlock.c:191:5: 
      189.     lockPtr->nextPtr = firstRwlockPtr;
      190.     firstRwlockPtr = lockPtr;
      191.     lockPtr->id = nextid++;
               ^
      192.     lockPtr->name[0] = 'r';
      193.     lockPtr->name[1] = 'w';

nsthread/rwlock.c:192:5: 
      190.     firstRwlockPtr = lockPtr;
      191.     lockPtr->id = nextid++;
      192.     lockPtr->name[0] = 'r';
               ^
      193.     lockPtr->name[1] = 'w';
      194.     (void) ns_uint64toa(&lockPtr->name[2], (uint64_t)lockPtr->id);

nsthread/rwlock.c:193:5: 
      191.     lockPtr->id = nextid++;
      192.     lockPtr->name[0] = 'r';
      193.     lockPtr->name[1] = 'w';
               ^
      194.     (void) ns_uint64toa(&lockPtr->name[2], (uint64_t)lockPtr->id);
      195.     Ns_MasterUnlock();

nsthread/rwlock.c:194:12: Skipping ns_uint64toa(): empty list of specs
      192.     lockPtr->name[0] = 'r';
      193.     lockPtr->name[1] = 'w';
      194.     (void) ns_uint64toa(&lockPtr->name[2], (uint64_t)lockPtr->id);
                      ^
      195.     Ns_MasterUnlock();
      196. 

nsthread/rwlock.c:194:5: 
      192.     lockPtr->name[0] = 'r';
      193.     lockPtr->name[1] = 'w';
      194.     (void) ns_uint64toa(&lockPtr->name[2], (uint64_t)lockPtr->id);
               ^
      195.     Ns_MasterUnlock();
      196. 

nsthread/rwlock.c:195:5: 
      193.     lockPtr->name[1] = 'w';
      194.     (void) ns_uint64toa(&lockPtr->name[2], (uint64_t)lockPtr->id);
      195.     Ns_MasterUnlock();
               ^
      196. 
      197.     lockPtr->rw = NS_READ;

nsthread/master.c:73:1: start of procedure Ns_MasterUnlock()
        71. }
        72. 
        73. void
            ^
        74. Ns_MasterUnlock(void)
        75. {

nsthread/master.c:76:9: Taking false branch
        74. Ns_MasterUnlock(void)
        75. {
        76.     if (initialized) {
                    ^
        77.         Ns_CsLeave(&master);
        78.     }

nsthread/master.c:76:5: 
        74. Ns_MasterUnlock(void)
        75. {
        76.     if (initialized) {
                ^
        77.         Ns_CsLeave(&master);
        78.     }

nsthread/master.c:79:1: return from a call to Ns_MasterUnlock
        77.         Ns_CsLeave(&master);
        78.     }
        79. }
            ^
        80. 
        81. 

nsthread/rwlock.c:197:5: 
      195.     Ns_MasterUnlock();
      196. 
      197.     lockPtr->rw = NS_READ;
               ^
      198.     {
      199.         int err;

nsthread/rwlock.c:202:9: Skipping pthread_rwlockattr_setkind_np(): method has no implementation
      200. #if (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 500) || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L)
      201.         pthread_rwlockattr_t attr;
      202.         pthread_rwlockattr_setkind_np(&attr,
                   ^
      203.                                       PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
      204.         err = pthread_rwlock_init(&lockPtr->rwlock, &attr);

nsthread/rwlock.c:204:9: Skipping pthread_rwlock_init(): method has no implementation
      202.         pthread_rwlockattr_setkind_np(&attr,
      203.                                       PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
      204.         err = pthread_rwlock_init(&lockPtr->rwlock, &attr);
                   ^
      205. #else
      206.         err = pthread_rwlock_init(&lockPtr->rwlock, NULL);

nsthread/rwlock.c:208:13: Taking false branch
      206.         err = pthread_rwlock_init(&lockPtr->rwlock, NULL);
      207. #endif
      208.         if (err != 0) {
                       ^
      209.             NsThreadFatal("Ns_RWLockInit", "pthread_rwlock_init", err);
      210.         }

nsthread/rwlock.c:212:5: 
      210.         }
      211.     }
      212.     *rwPtr = (Ns_RWLock) lockPtr;
               ^
      213. }
      214. 

nsthread/rwlock.c:213:1: return from a call to Ns_RWLockInit
      211.     }
      212.     *rwPtr = (Ns_RWLock) lockPtr;
      213. }
           ^
      214. 
      215. /*

nsthread/rwlock.c:506:9: 
    504.             Ns_RWLockInit(rwPtr);
    505.         }
    506.         Ns_MasterUnlock();
                 ^
    507.     }
    508.     return (RwLock *) *rwPtr;

nsthread/master.c:73:1: start of procedure Ns_MasterUnlock()
      71. }
      72. 
      73. void
          ^
      74. Ns_MasterUnlock(void)
      75. {

nsthread/master.c:76:9: Taking false branch
      74. Ns_MasterUnlock(void)
      75. {
      76.     if (initialized) {
                  ^
      77.         Ns_CsLeave(&master);
      78.     }

nsthread/master.c:76:5: 
      74. Ns_MasterUnlock(void)
      75. {
      76.     if (initialized) {
              ^
      77.         Ns_CsLeave(&master);
      78.     }

nsthread/master.c:79:1: return from a call to Ns_MasterUnlock
      77.         Ns_CsLeave(&master);
      78.     }
      79. }
          ^
      80. 
      81. 

nsthread/rwlock.c:508:5: 
    506.         Ns_MasterUnlock();
    507.     }
    508.     return (RwLock *) *rwPtr;
             ^
    509. }
    510. 

nsthread/rwlock.c:509:1: return from a call to GetRwLock
    507.     }
    508.     return (RwLock *) *rwPtr;
    509. }
         ^
    510. 
    511. #else /* NOT HAVE_PTHREAD */

nsthread/rwlock.c:344:5: Skipping pthread_rwlock_tryrdlock(): method has no implementation
  342.     lockPtr = GetRwLock(rwPtr);
  343. 
  344.     err = pthread_rwlock_tryrdlock(&lockPtr->rwlock);
           ^
  345.     if (unlikely(err == EBUSY)) {
  346.         busy = NS_TRUE;

nsthread/rwlock.c:345:9: Condition is false
  343. 
  344.     err = pthread_rwlock_tryrdlock(&lockPtr->rwlock);
  345.     if (unlikely(err == EBUSY)) {
               ^
  346.         busy = NS_TRUE;
  347.     } else if (unlikely(err != 0)) {

nsthread/rwlock.c:345:9: Taking false branch
  343. 
  344.     err = pthread_rwlock_tryrdlock(&lockPtr->rwlock);
  345.     if (unlikely(err == EBUSY)) {
               ^
  346.         busy = NS_TRUE;
  347.     } else if (unlikely(err != 0)) {

nsthread/rwlock.c:347:16: Condition is true
  345.     if (unlikely(err == EBUSY)) {
  346.         busy = NS_TRUE;
  347.     } else if (unlikely(err != 0)) {
                      ^
  348.         busy = NS_FALSE;
  349.         NsThreadFatal("Ns_RWLockRdLock", "pthread_rwlock_tryrdlock", err);

nsthread/rwlock.c:347:16: Taking true branch
  345.     if (unlikely(err == EBUSY)) {
  346.         busy = NS_TRUE;
  347.     } else if (unlikely(err != 0)) {
                      ^
  348.         busy = NS_FALSE;
  349.         NsThreadFatal("Ns_RWLockRdLock", "pthread_rwlock_tryrdlock", err);

nsthread/rwlock.c:348:9: 
  346.         busy = NS_TRUE;
  347.     } else if (unlikely(err != 0)) {
  348.         busy = NS_FALSE;
               ^
  349.         NsThreadFatal("Ns_RWLockRdLock", "pthread_rwlock_tryrdlock", err);
  350.     } else {

nsthread/rwlock.c:349:9: 
  347.     } else if (unlikely(err != 0)) {
  348.         busy = NS_FALSE;
  349.         NsThreadFatal("Ns_RWLockRdLock", "pthread_rwlock_tryrdlock", err);
               ^
  350.     } else {
  351.         busy = NS_FALSE;

nsthread/error.c:56:1: start of procedure NsThreadFatal()
    54.  */
    55. 
    56. void
        ^
    57. NsThreadFatal(const char *func, const char *osfunc, int err)
    58. {

nsthread/error.c:62:5: Skipping Tcl_Panic(): method has no implementation
    60.     Tcl_Panic("nsthreads: %s failed in %s: win32 err: %d", osfunc, func, err);
    61. #else
    62.     Tcl_Panic("nsthreads: %s failed in %s: %s", osfunc, func, strerror(err));
            ^
    63. #endif
    64. }

nsthread/error.c:64:1: return from a call to NsThreadFatal
    62.     Tcl_Panic("nsthreads: %s failed in %s: %s", osfunc, func, strerror(err));
    63. #endif
    64. }
        ^
    65. 
    66. #ifdef _WIN32

nsthread/rwlock.c:363:1: return from a call to Ns_RWLockRdLock
  361.     lockPtr->nlock++;
  362.     lockPtr->nrlock++;
  363. }
       ^
  364. 
  365. 

nsd/tclcache.c:377:9: 
375. 
376.         Ns_RWLockRdLock(&servPtr->tcl.cachelock);
377.         maxSize  = (long)cPtr->maxSize;
             ^
378.         maxEntry = (long)cPtr->maxEntry;
379.         Ns_RWLockUnlock(&servPtr->tcl.cachelock);