index.c

Bug Summary

File:	d/index.c
Warning:	line 322, column 13 Memory copy function accesses out-of-bound array element

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name index.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/isvv/naviserver/nsd -resource-dir /usr/local/lib/clang/15.0.0 -D _FORTIFY_SOURCE=2 -D NDEBUG -D SYSTEM_MALLOC -I ../include -I /usr/include/tcl8.6 -D HAVE_CONFIG_H -internal-isystem /usr/local/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c99 -fdebug-compilation-dir=/home/isvv/naviserver/nsd -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-checker alpha -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-07-23-130959-11103-1 -x c index.c

1/*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://mozilla.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is AOLserver Code and related documentation
* distributed by AOL.
*
* The Initial Developer of the Original Code is America Online,
* Inc. Portions created by AOL are Copyright (C) 1999 America Online,
* Inc. All Rights Reserved.
*
* Alternatively, the contents of this file may be used under the terms
* of the GNU General Public License (the "GPL"), in which case the
* provisions of GPL are applicable instead of those above.  If you wish
* to allow use of your version of this file only under the terms of the
* GPL and not to allow others to use your version of this file under the
* License, indicate your decision by deleting the provisions above and
* replace them with the notice and other provisions required by the GPL.
* If you do not delete the provisions above, a recipient may use your
* version of this file under either the License or the GPL.
*/


31/*
* index.c --
*
*      Implement the index data type.
*/

37#include "nsd.h"

39/*
* Local functions defined in this file
*/

43static ssize_t BinSearch(void *const*elPtrPtr, void *const* listPtrPtr, ssize_t n, Ns_IndexCmpProc *cmpProc)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4)));
45static ssize_t BinSearchKey(const void *key, void *const*listPtrPtr, ssize_t n, Ns_IndexCmpProc *cmpProc)
  NS_GNUC_NONNULL(1)__attribute__((__nonnull__(1))) NS_GNUC_NONNULL(2)__attribute__((__nonnull__(2))) NS_GNUC_NONNULL(4)__attribute__((__nonnull__(4)));

48static Ns_IndexCmpProc CmpStr;
49static Ns_IndexKeyCmpProc CmpKeyWithStr;

51static Ns_IndexCmpProc CmpInts;
52static Ns_IndexKeyCmpProc CmpKeyWithInt;

54#ifdef _MSC_VER_VERY_OLD
55static void *
56NsBsearch (register const void *key, register const void *base,
         register size_t nmemb, register size_t size,
         int (*compar)(const void *left, const void *right));
59#endif

61
62/*
*----------------------------------------------------------------------
*
* Ns_IndexInit --
*
*      Initialize a new index.
*
* Results:
*      None.
*
* Side effects:
*      Will allocate space for the index elements from the heap.
*
*----------------------------------------------------------------------
*/

78void
79Ns_IndexInit(Ns_Index *indexPtr, size_t inc,
           int (*CmpEls) (const void *left, const void *right),
           int (*CmpKeyWithEl) (const void *left, const void *right))
82{

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(CmpEls != NULL)((void) (0));
  NS_NONNULL_ASSERT(CmpKeyWithEl != NULL)((void) (0));

  indexPtr->n = 0u;
  indexPtr->max = inc;
  indexPtr->inc = inc;

  indexPtr->CmpEls = CmpEls;
  indexPtr->CmpKeyWithEl = CmpKeyWithEl;

  indexPtr->el = (void **) ns_malloc((size_t)inc * sizeof(void *));
96}

98
99/*
*----------------------------------------------------------------------
*
* Ns_IndexTrunc --
*
*      Remove all elements from an index.
*
* Results:
*      None.
*
* Side effects:
*      Frees and mallocs element memory.
*
*----------------------------------------------------------------------
*/

115void
116Ns_IndexTrunc(Ns_Index* indexPtr)
117{
  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  indexPtr->n = 0u;
  ns_free(indexPtr->el);
  indexPtr->max = indexPtr->inc;
  indexPtr->el = (void **) ns_malloc((size_t)indexPtr->inc * sizeof(void *));
124}

126
127/*
*----------------------------------------------------------------------
*
* Ns_IndexDestroy --
*
*      Release all of an index's memory.
*
* Results:
*      None.
*
* Side effects:
*      Frees elements.
*
*----------------------------------------------------------------------
*/

143void
144Ns_IndexDestroy(Ns_Index *indexPtr)
145{
  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  indexPtr->CmpEls = NULL((void*)0);
  indexPtr->CmpKeyWithEl = NULL((void*)0);
  ns_free(indexPtr->el);
151}

153
154/*
*----------------------------------------------------------------------
*
* Ns_IndexDup --
*
*      Make a copy of an index.
*
* Results:
*      A pointer to a copy of the index.
*
* Side effects:
*      Mallocs memory for index and elements.
*
*----------------------------------------------------------------------
*/

170Ns_Index *
171Ns_IndexDup(const Ns_Index *indexPtr)
172{
  Ns_Index *newPtr;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  newPtr = (Ns_Index *) ns_malloc(sizeof(Ns_Index));
  memcpy(newPtr, indexPtr, sizeof(Ns_Index));
  newPtr->el = (void **) ns_malloc(indexPtr->max * sizeof(void *));
  memcpy(newPtr->el, indexPtr->el, indexPtr->n * sizeof(void *));

  return newPtr;
183}

185
186/*
*----------------------------------------------------------------------
*
* Ns_IndexFind --
*
*      Find a key in an index.
*
* Results:
*      A pointer to the element, or NULL if none found.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

202void *
203Ns_IndexFind(const Ns_Index *indexPtr, const void *key)
204{
  void *const *pPtrPtr;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(key != NULL)((void) (0));

  pPtrPtr = (void **) bsearch(key, indexPtr->el, indexPtr->n,
                              sizeof(void *), indexPtr->CmpKeyWithEl);

  return (pPtrPtr != NULL((void*)0)) ? *pPtrPtr : NULL((void*)0);
214}

216
217/*
*----------------------------------------------------------------------
*
* Ns_IndexFindInf --
*
*      Find the element with the key, or if none exists, the element
*      before which the key would appear.
*
* Results:
*      An element, or NULL if the key is not there AND would be the
*      last element in the list.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

235void *
236Ns_IndexFindInf(const Ns_Index *indexPtr, const void *key)
237{
  void *result = NULL((void*)0);

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(key != NULL)((void) (0));

  if (indexPtr->n > 0u) {
      ssize_t i = BinSearchKey(key, indexPtr->el, (ssize_t)indexPtr->n,
                           indexPtr->CmpKeyWithEl);

      if (i < (ssize_t)indexPtr->n) {
          if ((i > 0) &&
              ((indexPtr->CmpKeyWithEl)(key, &(indexPtr->el[i])) != 0))  {
              result = indexPtr->el[i - 1];
          } else {
              result = indexPtr->el[i];
          }
      }
  }

  return result;
258}

260
261/*
*----------------------------------------------------------------------
*
* Ns_IndexFindMultiple --
*
*      Find all elements that match key.
*
* Results:
*      An array of pointers to matching elements, terminated with a
*      null pointer.
*
* Side effects:
*      Will allocate memory for the return result.
*
*----------------------------------------------------------------------
*/

278void **
279Ns_IndexFindMultiple(const Ns_Index *indexPtr, const void *key)
280{
  void *const  *firstPtrPtr;
  void        **retPtrPtr = NULL((void*)0);

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(key != NULL)((void) (0));

  /*
   * Find a place in the array that matches the key
   */
  firstPtrPtr = (void **) bsearch(key, indexPtr->el, indexPtr->n,
                                  sizeof(void *), indexPtr->CmpKeyWithEl);

  if (firstPtrPtr != NULL((void*)0)) {
1
Assuming 'firstPtrPtr' is not equal to NULL→
2
←
Taking true branch→
      size_t i, n;

      /*
       * Search linearly back to make sure we've got the first one
       */

      while (firstPtrPtr != indexPtr->el
3
←
Assuming 'firstPtrPtr' is not equal to field 'el'→
5
←
Loop condition is true.  Entering loop body→
6
←
Assuming 'firstPtrPtr' is equal to field 'el'→
          && indexPtr->CmpKeyWithEl(key, firstPtrPtr - 1) == 0) {
4
←
Assuming the condition is true→
          firstPtrPtr--;
      }

      /*
       * Search linearly forward to find out how many there are
       */
      n = indexPtr->n - (size_t)(firstPtrPtr - indexPtr->el);
      for (i = 1u;
           i < n && indexPtr->CmpKeyWithEl(key, firstPtrPtr + i) == 0;
7
←
Assuming 'i' is >= 'n'→
           i++) {
          ;
      }

      /*
       * Build array of values to return
       */
      retPtrPtr = ns_malloc((i + 1u) * sizeof(void *));
      if (unlikely(retPtrPtr == NULL)(__builtin_expect((retPtrPtr == ((void*)0)), 0))) {
8
←
Assuming 'retPtrPtr' is not equal to null→
9
←
Taking false branch→
          Ns_Fatal("IndexFindMultiple: out of memory while allocating result");
      } else {
          memcpy(retPtrPtr, firstPtrPtr, i * sizeof(void *));
10
←
Memory copy function accesses out-of-bound array element
          retPtrPtr[i] = NULL((void*)0);
      }
  }

  return retPtrPtr;
328}

330
331/*
*----------------------------------------------------------------------
*
* BinSearch --
*
*      Modified from BinSearch in K&R.
*
* Results:
*      The position where an element should be inserted even if it
*      does not already exist. "bsearch" will just return NULL.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

348static ssize_t
349BinSearch(void *const* elPtrPtr, void *const* listPtrPtr, ssize_t n, Ns_IndexCmpProc *cmpProc)
350{
  ssize_t low = 0, high = n-1, mid = 0;

  NS_NONNULL_ASSERT(elPtrPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(listPtrPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(cmpProc != NULL)((void) (0));

  while (low <= high) {
      int cond;

      mid = (low + high) / 2;
      cond = (*cmpProc) (elPtrPtr, ((const unsigned char *const*)listPtrPtr) + mid);
      if (cond < 0) {
          high = mid - 1;
      } else if (cond > 0) {
          low = mid + 1;
      } else {
          return mid;
      }
  }
  return (high < mid) ? mid : low;
371}

373
374/*
*----------------------------------------------------------------------
*
* BinSearchKey --
*
*      Like BinSearch, but takes a key instead of an element
*      pointer.
*
* Results:
*      See BinSearch.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

391static ssize_t
392BinSearchKey(const void *key, void *const* listPtrPtr, ssize_t n, Ns_IndexCmpProc *cmpProc)
393{
  ssize_t low = 0, high = n-1, mid = 0;

  NS_NONNULL_ASSERT(key != NULL)((void) (0));
  NS_NONNULL_ASSERT(listPtrPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(cmpProc != NULL)((void) (0));

  while (low <= high) {
      int cond;

      mid = (low + high) / 2;
      cond = (*cmpProc)(key, ((const unsigned char *const*)listPtrPtr) + mid);
      if (cond < 0) {
          high = mid - 1;
      } else if (cond > 0) {
          low = mid + 1;
      } else {
          return mid;
      }
  }
  return (high < mid) ? mid : low;
414}

416
417/*
*----------------------------------------------------------------------
*
* Ns_IndexAdd --
*
*      Add an element to an index.
*
* Results:
*      None.
*
* Side effects:
*      May allocate extra element memory.
*
*----------------------------------------------------------------------
*/

433void
434Ns_IndexAdd(Ns_Index *indexPtr, void *el)
435{
  ssize_t i;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(el != NULL)((void) (0));

  if (indexPtr->n == indexPtr->max) {
      indexPtr->max += indexPtr->inc;
      indexPtr->el = (void **) ns_realloc(indexPtr->el,
                                          indexPtr->max * sizeof(void *));
  } else if (indexPtr->max == 0u) {
      indexPtr->max = indexPtr->inc;
      indexPtr->el = (void **) ns_malloc(indexPtr->max * sizeof(void *));
  }
  if (indexPtr->n > 0u) {
      i = BinSearch(&el, indexPtr->el, (ssize_t)indexPtr->n, indexPtr->CmpEls);
  } else {
      i = 0;
  }

  if (i < (int)indexPtr->n) {
      size_t j;

      for (j = indexPtr->n; (int)j > i; j--) {
          indexPtr->el[j] = indexPtr->el[j - 1u];
      }
  }
  indexPtr->el[i] = el;
  indexPtr->n++;
464}

466
467/*
*----------------------------------------------------------------------
*
* Ns_IndexDel --
*
*      Remove an element from an index.
*
* Results:
*      None.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

483void
484Ns_IndexDel(Ns_Index *indexPtr, const void *el)
485{
  size_t i, j;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(el != NULL)((void) (0));

  for (i = 0u; i < indexPtr->n; i++) {
      if (indexPtr->el[i] == el) {
          indexPtr->n--;
          if (i < indexPtr->n) {
              for (j = i; j < indexPtr->n; j++) {
                  indexPtr->el[j] = indexPtr->el[j + 1u];
              }
          }
          break;
      }
  }
502}

504
505/*
*----------------------------------------------------------------------
*
* Ns_IndexEl --
*
*      Find the i'th element of an index.
*
* Results:
*      Element.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

521void *
522Ns_IndexEl(const Ns_Index *indexPtr, size_t i)
523{
  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  return indexPtr->el[i];
527}

529
530/*
*----------------------------------------------------------------------
*
* CmpStr --
*
*      Default comparison function.
*
* Results:
*      See strcmp.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

546static int
547CmpStr(const void *leftPtr, const void *rightPtr)
548{
  NS_NONNULL_ASSERT(leftPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(rightPtr != NULL)((void) (0));

  return strcmp(*(const char**)leftPtr, *((const char**)rightPtr));
553}

555
556/*
*----------------------------------------------------------------------
*
* CmpKeyWithStr --
*
*      Default comparison function, with key.
*
* Results:
*      See strcmp.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

572static int
573CmpKeyWithStr(const void *key, const void *elPtr)
574{
  NS_NONNULL_ASSERT(key != NULL)((void) (0));
  NS_NONNULL_ASSERT(elPtr != NULL)((void) (0));

  return strcmp((const char *)key, *(const char *const*)elPtr);
579}

581
582/*
*----------------------------------------------------------------------
*
* Ns_IndexStringInit --
*
*      Initialize an index where the elements themselves are
*      strings.
*
* Results:
*      None.
*
* Side effects:
*      See Ns_IndexInit.
*
*----------------------------------------------------------------------
*/

599void
600Ns_IndexStringInit(Ns_Index *indexPtr, size_t inc)
601{
  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  Ns_IndexInit(indexPtr, inc, CmpStr, CmpKeyWithStr);
605}

607
608/*
*----------------------------------------------------------------------
*
* Ns_IndexStringDup --
*
*      Make a copy of an index, using ns_strdup to duplicate the
*      keys.
*
* Results:
*      A new index.
*
* Side effects:
*      Will make memory copies of the elements.
*
*----------------------------------------------------------------------
*/

625Ns_Index *
626Ns_IndexStringDup(const Ns_Index *indexPtr)
627{
  Ns_Index *newPtr;
  size_t    i;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  newPtr = (Ns_Index *) ns_malloc(sizeof(Ns_Index));
  memcpy(newPtr, indexPtr, sizeof(Ns_Index));
  newPtr->el = (void **) ns_malloc(indexPtr->max * sizeof(void *));

  for (i = 0u; i < newPtr->n; i++) {
      newPtr->el[i] = ns_strdup(indexPtr->el[i]);
  }

  return newPtr;
642}

644
645/*
*----------------------------------------------------------------------
*
* Ns_IndexStringAppend --
*
*      Append one index of strings to another.
*
* Results:
*      None.
*
* Side effects:
*      Will append to the first index.
*
*----------------------------------------------------------------------
*/

661void
662Ns_IndexStringAppend(Ns_Index *addtoPtr, const Ns_Index *addfromPtr)
663{
  size_t i;

  NS_NONNULL_ASSERT(addtoPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(addfromPtr != NULL)((void) (0));

  for (i = 0u; i < addfromPtr->n; i++) {
      Ns_IndexAdd(addtoPtr, ns_strdup(addfromPtr->el[i]));
  }
672}

674
675/*
*----------------------------------------------------------------------
*
* Ns_IndexStringDestroy --
*
*      Free an index of strings.
*
* Results:
*      None.
*
* Side effects:
*      See Ns_IndexDestroy.
*
*----------------------------------------------------------------------
*/

691void
692Ns_IndexStringDestroy(Ns_Index *indexPtr)
693{
  size_t i;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  for (i = 0u; i < indexPtr->n; i++) {
      ns_free(indexPtr->el[i]);
  }

  Ns_IndexDestroy(indexPtr);
703}

705
706/*
*----------------------------------------------------------------------
*
* Ns_IndexStringTrunc --
*
*      Remove all elements from an index of strings.
*
* Results:
*      None.
*
* Side effects:
*      See Ns_IndexTrunc.
*
*----------------------------------------------------------------------
*/

722void
723Ns_IndexStringTrunc(Ns_Index *indexPtr)
724{
  size_t i;

  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  for (i = 0u; i < indexPtr->n; i++) {
      ns_free(indexPtr->el[i]);
  }

  Ns_IndexTrunc(indexPtr);
734}

736
737/*
*----------------------------------------------------------------------
*
* CmpInts --
*
*      Default comparison function for an index of ints.
*
* Results:
*      -1: left < right; 1: left > right; 0: left == right
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

753static int
754CmpInts(const void *leftPtr, const void *rightPtr)
755{
  int result, left, right;

  NS_NONNULL_ASSERT(leftPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(rightPtr != NULL)((void) (0));

  left = *(const int *)leftPtr;
  right = *(const int *)rightPtr;

  if (left == right) {
      result = 0;
  } else {
      result = (left < right) ? -1 : 1;
  }
  return result;
770}

772
773/*
*----------------------------------------------------------------------
*
* CmpKeyWithInt --
*
*      Default comparison function for an index of ints, with key.
*
* Results:
*      -1: key < el; 1: key > el; 0: key == el
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

789static int
790CmpKeyWithInt(const void *keyPtr, const void *elPtr)
791{
  int result, key, element;

  NS_NONNULL_ASSERT(keyPtr != NULL)((void) (0));
  NS_NONNULL_ASSERT(elPtr != NULL)((void) (0));

  key = *(const int *)keyPtr;
  element = *(const int *)elPtr;

  if (key == element) {
      result = 0;
  } else {
      result = key < element ? -1 : 1;
  }
  return result;
806}

808
809/*
*----------------------------------------------------------------------
*
* Ns_IndexIntInit --
*
*      Initialize an index whose elements will be integers.
*
* Results:
*      None.
*
* Side effects:
*      See Ns_IndexInit.
*
*----------------------------------------------------------------------
*/

825void
826Ns_IndexIntInit(Ns_Index *indexPtr, size_t inc)
827{
  NS_NONNULL_ASSERT(indexPtr != NULL)((void) (0));

  Ns_IndexInit(indexPtr, inc, CmpInts, CmpKeyWithInt);
831}

833#ifdef _MSC_VER_VERY_OLD
834#define bsearch(a, b, c, d, e) NsBsearch((a), (b), (c), (d), (e))

836/*
*----------------------------------------------------------------------
*
* NsBsearch --
*
*      Binary search.
*
*  Due to Windows hanging in its own bsearch() routine, this was added
*  to alleviate the problem.
*
* Results:
*      A pointer to the element, or NULL if none found.
*
* Side effects:
*      None.
*
*----------------------------------------------------------------------
*/

855static void *
856NsBsearch (register const void *key, register const void *base,
         register size_t nmemb, register size_t size,
         int (*compar)(const void *key, const void *value))
859{
  while (nmemb > 0) {
      register const void *mid_point;
      register int         cmp;

      mid_point = (char *)base + size * (nmemb >> 1);
      if ((cmp = (*compar)(key, mid_point)) == 0)
          return (void *)mid_point;
      if (cmp >= 0) {
          base  = (char *)mid_point + size;
          nmemb = (nmemb - 1) >> 1;
      } else
          nmemb >>= 1;
  }
  return NULL((void*)0);
874}
875#endif

877/*
* Local Variables:
* mode: c
* c-basic-offset: 4
* fill-column: 78
* indent-tabs-mode: nil
* End:
*/