home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / progm / cbase.zip / CBASE10B.ZIP / CBASE.ZIP / CBOPS.C < prev    next >
Text File  |  1989-11-08  |  5KB  |  217 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "cbops.c    1.2 - 89/11/08" */
  5.  
  6. #include <blkio.h>
  7. #include <bool.h>
  8. #include <btree.h>
  9. #include <errno.h>
  10. /*#include <stddef.h>*/
  11. /*#include <stdlib.h>*/
  12. /*#include <string.h>*/
  13. #include "cbase_.h"
  14.  
  15. /*man---------------------------------------------------------------------------
  16. NAME
  17.      cb_alloc - allocate memory for cbase
  18.  
  19. SYNOPSIS
  20.      #include "cbase_.h"
  21.  
  22.      int cb_alloc(cbp);
  23.      cbase_t *cbp;
  24.  
  25. DESCRIPTION
  26.      The cb_alloc function allocates the memory needed by cbp.  The
  27.      memory is is initialized to all zeros.
  28.  
  29.      cb_alloc will fail if one or more of the following is true:
  30.  
  31.      [EINVAL]       cbp is not a valid cbase pointer.
  32.      [ENOMEM]       Not enough memory is available for
  33.                     allocation by the calling process.
  34.      [CBENOPEN]     cbp is not open.
  35.  
  36. SEE ALSO
  37.      cb_free.
  38.  
  39. DIAGNOSTICS
  40.      Upon successful completion, a value of 0 is returned.  Otherwise,
  41.      a value of -1 is returned, and errno set to indicate the error.
  42.  
  43. ------------------------------------------------------------------------------*/
  44. int cb_alloc(cbp)
  45. cbase_t *cbp;
  46. {
  47. #ifdef DEBUG
  48.     /* validate arguments */
  49.     if (!cb_valid(cbp)) {
  50.         CBEPRINT;
  51.         errno = EINVAL;
  52.         return -1;
  53.     }
  54.  
  55.     /* check if not open */
  56.     if (!(cbp->flags & CBOPEN)) {
  57.         CBEPRINT;
  58.         errno = CBENOPEN;
  59.         return -1;
  60.     }
  61.  
  62.     /* check for memory leak */
  63.     if ((cbp->fldv != NULL) || (cbp->btpv != NULL)) {
  64.         CBEPRINT;
  65.         errno = CBEPANIC;
  66.         return -1;
  67.     }
  68. #endif
  69.  
  70.     /* field definition array */
  71.     cbp->fldv = (cbfield_t *)calloc((size_t)cbp->fldc, sizeof(*cbp->fldv));
  72.     if (cbp->fldv == NULL) {
  73.         CBEPRINT;
  74.         errno = ENOMEM;
  75.         return -1;
  76.     }
  77.  
  78.     /* btree array */
  79.     cbp->btpv = (btree_t **)calloc((size_t)cbp->fldc, sizeof(*cbp->btpv));
  80.     if (cbp->btpv == NULL) {
  81.         CBEPRINT;
  82.         free(cbp->fldv);
  83.         errno = ENOMEM;
  84.         return -1;
  85.     }
  86.  
  87.     errno = 0;
  88.     return 0;
  89. }
  90.  
  91. /*man---------------------------------------------------------------------------
  92. NAME
  93.      cb_free - free memory allocated for cbase
  94.  
  95. SYNOPSIS
  96.      #include "cbase_.h"
  97.  
  98.      void cb_free(cbp)
  99.      cbase_t *cbp;
  100.  
  101. DESCRIPTION
  102.      The cb_free function frees all memory allocated for cbase cbp.
  103.      If cbp is not a valid cbase, no action is taken.
  104.  
  105. SEE ALSO
  106.      cb_alloc.
  107.  
  108. ------------------------------------------------------------------------------*/
  109. void cb_free(cbp)
  110. cbase_t *cbp;
  111. {
  112. #ifdef DEBUG
  113.     /* validate arguments */
  114.     if (!cb_valid(cbp)) {
  115.         CBEPRINT;
  116.         return;
  117.     }
  118. #endif
  119.  
  120.     /* free memory */
  121.     if (cbp->fldv != NULL) {
  122.         free(cbp->fldv);
  123.         cbp->fldv = NULL;
  124.     }
  125.     if (cbp->btpv != NULL) {
  126.         free(cbp->btpv);
  127.         cbp->btpv = NULL;
  128.     }
  129.  
  130.     return;
  131. }
  132.  
  133. /*man---------------------------------------------------------------------------
  134. NAME
  135.      cb_fvalid - validate field definition list
  136.  
  137. SYNOPSIS
  138.      #include "cbase_.h"
  139.  
  140.      bool cb_fvalid(recsize, fldc, fldv)
  141.      size_t recsize;
  142.      int fldc;
  143.      const cbfield_t fldv[];
  144.  
  145. DESCRIPTION
  146.      The cb_fvalid function determines if fldc and fldv constitute a
  147.      valid field definition list for a cbase with records of size
  148.      recsize.  If valid, then TRUE is returned.  If not, then FALSE is
  149.      returned.
  150.  
  151. ------------------------------------------------------------------------------*/
  152. bool cb_fvalid(recsize, fldc, fldv)
  153. size_t recsize;
  154. int fldc;
  155. CONST cbfield_t fldv[];
  156. {
  157.     int end = 0;
  158.  
  159.     if ((recsize < sizeof(bpos_t)) || (fldv == NULL) || (fldc < 1)) {
  160.         return FALSE;
  161.     }
  162.  
  163.     for (end = 0; fldc-- > 0; fldv++) {
  164.         if (fldv->offset < end) {
  165.             return FALSE;
  166.         }
  167.         if (fldv->len < 1) {
  168.             return FALSE;
  169.         }
  170.         end = fldv->offset + fldv->len;
  171.         if (end > recsize) {
  172.             return FALSE;
  173.         }
  174.         if ((fldv->type < 0) || (fldv->type >= CBTYPECNT)) {
  175.             return FALSE;
  176.         }
  177.         if (fldv->flags & ~CB_FFLAGS) {
  178.             return FALSE;
  179.         }
  180.         if (fldv->flags & CB_FKEY) {
  181.             if (fldv->filename[0] == '\0') {
  182.                 return FALSE;
  183.             }
  184.         }
  185.     }
  186.  
  187.     return TRUE;
  188. }
  189.  
  190. /*man---------------------------------------------------------------------------
  191. NAME
  192.      cb_valid - validate cbase pointer
  193.  
  194. SYNOPSIS
  195.      #include "cbase_.h"
  196.  
  197.      bool cb_valid(cbp)
  198.      cbase_t *cbp;
  199.  
  200. DESCRIPTION
  201.      The cb_valid function determines if cbp is a valid cbase pointer.
  202.      If valid, then TRUE is returned.  If not, then FALSE is returned.
  203.  
  204. ------------------------------------------------------------------------------*/
  205. bool cb_valid(cbp)
  206. cbase_t *cbp;
  207. {
  208.     if ((cbp < cbb) || (cbp > (cbb + CBOPEN_MAX - 1))) {
  209.         return FALSE;
  210.     }
  211.     if ((((char *)cbp - (char *)cbb)) % sizeof(*cbb) != 0) {
  212.         return FALSE;
  213.     }
  214.  
  215.     return TRUE;
  216. }
  217.