---

cms_up.cc

Go to the documentation of this file.

/***************************************************************************
* File: cms_up.cc
* Author(s): Will Shackleford, Fred Proctor
* Purpose: Provides the interface to CMS used by NML update functions including
* a CMS update function for all the basic C data types.
*
* NOTES:
* There are no update functions for enumerations, or pointers.
****************************************************************************/

/* Includes */
#include "cms.hh"               /* class CMS */
#include "cms_up.hh"            /* class CMS_UPDATER */
#include "rcs_prnt.hh"          /* rcs_print_error() */
#include "dbg_mem.h"            // DEBUG_MALLOC,DEBUG_FREE

#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif
#include <stdlib.h>             // malloc(), free()
#include <string.h>             // memset()
#ifdef EXTERN_C_STD_HEADERS
}
#endif

/* Member functions for CMS_UPDATER Class */
CMS_UPDATER::CMS_UPDATER (CMS * _cms_parent, int create_encoded_data,
                          long _neutral_size_factor):
  /**********************************************
  * Aliases to variables in the CMS parent
  * using aliases lets CMS and its CMS_UPDATER share this information
  * more conveniently and allowed the CMS_UPDATER functions to be pulled out
  * of CMS with fewer changes. (WPS - 6/12/95)
  *********************************************/
encoded_data (_cms_parent->encoded_data),
encoded_header (_cms_parent->encoded_header),
encoded_queuing_header (_cms_parent->encoded_queuing_header),
status (_cms_parent->status),
size (_cms_parent->size),
encoded_header_size (_cms_parent->encoded_header_size),
encoded_queuing_header_size (_cms_parent->encoded_queuing_header_size),
using_external_encoded_data (_cms_parent->using_external_encoded_data),
pointer_check_disabled (_cms_parent->pointer_check_disabled),
encoded_data_size (_cms_parent->encoded_data_size)
{
  cms_parent = _cms_parent;
  mode = CMS_NO_UPDATE;
  neutral_size_factor = _neutral_size_factor;
  if (encoded_data == NULL && create_encoded_data)
    {
      if (cms_parent->enc_max_size > 0
          && cms_parent->enc_max_size < neutral_size_factor * size)
        {
          set_encoded_data (DEBUG_MALLOC (cms_parent->enc_max_size),
                            cms_parent->enc_max_size);
        }
      else
        {
          set_encoded_data (DEBUG_MALLOC (neutral_size_factor * size),
                            neutral_size_factor * size);
        }
      using_external_encoded_data = 0;
    }
}

CMS_UPDATER::~CMS_UPDATER ()
{
#ifdef CMS_SUPPORT_POINTERS
  if (NULL != ptr_table)
    {
      delete ptr_table;
    }
#endif
}

#ifdef CMS_SUPPORT_POINTERS

CMS_STATUS
  CMS_UPDATER::update_ptr (int (*update_ptr_func) (void *, CMS *),
                           void **x, long xsize)
{
  if (NULL == update_ptr_func || NULL == x)
    {
      return (status = CMS_UPDATE_ERROR);
    }

  int padsize;
  int table_index = pointers_in_table;

  if (encoding)
    {
      if (NULL == *x)
        {
          table_index = -1;
          pointer_check_disabled = 1;
          update (table_index);
          pointer_check_disabled = 0;
          return (status);
        }
      ptr_table_entry = ptr_table;
      table_index = 0;
      while (ptr_table_entry->ptr != *x && ptr_table_entry->ptr != NULL)
        {
          ptr_table_entry++;
          table_index++;
        }
      if (ptr_table_entry->ptr == NULL)
        {
          pointers_in_table++;
          ptr_table_entry->ptr = *x;
          pointer_check_disabled = 1;
          update (pointers_in_table);
          pointer_check_disabled = 0;
          update_ptr_func (*x, cms_parent);
        }
      else
        {
          pointer_check_disabled = 1;
          update (table_index);
          pointer_check_disabled = 0;
        }
    }
  else
    {
      pointer_check_disabled = 1;
      update (table_index);
      pointer_check_disabled = 0;
      if (table_index == -1)
        {
          *x = NULL;
          return (status);
        }
      if (table_index < pointers_in_table)
        {
          *x = ptr_table[table_index].ptr;
        }
      else
        {
          if (NULL == unused_pointer_buf || xsize > unused_pointer_buf_size)
            {
              return (status = CMS_UPDATE_ERROR);
            }
          *x = (void *) unused_pointer_buf;
          unused_pointer_buf_size -= ((long) xsize);
          unused_pointer_buf += xsize;
          if (((unsigned long) unused_pointer_buf) % 16 != 0)
            {
              padsize = 16 - ((unsigned long) unused_pointer_buf) % 16;
              unused_pointer_buf_size -= ((long) padsize);
              unused_pointer_buf += padsize;
            }
          update_ptr_func (*x, cms_parent);
          ptr_table_entry->ptr = *x;
          ptr_table_entry++;
          pointers_in_table++;
        }
    }
  return (status);
}

CMS_STATUS
CMS_UPDATER::set_pointer_buffer (char *_buf, long _size)
{
  unsigned int padsize;
  unused_pointer_buf = pointer_buf = _buf;
  unused_pointer_buf_size = pointer_buf_size = _size;
  if (((unsigned long) unused_pointer_buf) % 16 != 0)
    {
      padsize = 16 - ((unsigned long) unused_pointer_buf) % 16;
      unused_pointer_buf_size -= ((long) padsize);
      unused_pointer_buf += padsize;
    }
  return (status);
}

#endif
  // ifdef CMS_SUPPORT_POINTERS

void
CMS_UPDATER::rewind ()
{
}

int
CMS_UPDATER::set_mode (CMS_UPDATER_MODE _mode)
{
  mode = _mode;
  switch (mode)
    {
    case CMS_NO_UPDATE:
      break;

    case CMS_ENCODE_DATA:
      encoding = 1;
      break;

    case CMS_DECODE_DATA:
      encoding = 0;
      break;

    case CMS_ENCODE_HEADER:
      encoding = 1;
      break;

    case CMS_DECODE_HEADER:
      encoding = 0;
      break;

    case CMS_ENCODE_QUEUING_HEADER:
      encoding = 1;
      break;

    case CMS_DECODE_QUEUING_HEADER:
      encoding = 0;
      break;

    default:
      rcs_print_error ("CMS updater in invalid mode.\n");
      return (-1);
    }
  return (0);
}

CMS_UPDATER_MODE
CMS_UPDATER::get_mode ()
{
  return mode;
}


int
CMS_UPDATER::check_pointer (char RCS_HUGE * _pointer, long _bytes)
{
  if (NULL == cms_parent)
    {
      return (-1);
    }
  return (cms_parent->check_pointer (_pointer, _bytes));
}

void
CMS_UPDATER::set_encoded_data (void *_encoded_data, long _encoded_data_size)
{
  if (NULL != encoded_data &&
      !using_external_encoded_data && encoded_data != _encoded_data)
    {
      DEBUG_FREE (encoded_data);
      encoded_data = NULL;
    }
  encoded_data = _encoded_data;
  encoded_data_size = _encoded_data_size;
  using_external_encoded_data = 1;
}

---