---

nmlcfg.cc

Go to the documentation of this file.

#include <stdio.h>              // fprintf, fopen, fgets
#include <stdlib.h>             // exit(), size_t
#include <string.h>             // strcmp(),strncpy()
#include <errno.h>              // errno


#include "linklist.hh"          // RCS_LINKED_LIST;
#include "rcs_prnt.hh"          // seperate_words()
#include "cms.hh"               // CMS_BUFFERTYPE, CMS_REMOTE_PORT_TYPE

static int default_lines_detected = 0;

class BUFFER_INFO
{
public:
  BUFFER_INFO ();
  void initialize ();
  int oldstyle;
  char name[80];
  char host[80];
  CMS_BUFFERTYPE buftype;
  long orig_size;
  long size;
  int neut;
  int buffer_number;
  int shmem_key;
  int bsem_key;
  int max_proc;
  unsigned long vme_addr;
  CMS_REMOTE_PORT_TYPE remotetype;
  int remote_port;
  CMS_NEUTRAL_ENCODING_METHOD encoding_type;
  int queue;
  char endline[80];
  int comment_num;
  int processes_connected;
  int force_type;
  int bbd_size;
  double brpi;
  int enable_diag;
  int bufline_line_number;
  int use_autocnum;
  RCS_LINKED_LIST proc_list;
};

enum OPS_TYPE
{
  NO_OPS,
  READ_ONLY,
  WRITE_ONLY,
  READ_WRITE
};

char ops_string[4][3] = {
  "NO",
  "R",
  "W",
  "RW"
};


class PROCESS_INFO
{
public:
  PROCESS_INFO ();
  void initialize ();
  char name[80];
  int oldstyle;
  char bufname[80];
  char host[80];
  BUFFER_INFO *buf_info;
  CMS_PROCESSTYPE proctype;
  int isserver;
  double timeout;
  double subscription_interval;
  int master;
  int c_num;
  OPS_TYPE ops;
  char endline[80];
  int comment_num;
  double retry_interval;
};
class VAR_INFO
{
public:
  char name[80];
  int namelen;
  char val[80];
  int vallen;
    VAR_INFO ();
};



int nmlcfg_read_file (char *filename);
int is_true (char *str);
int parse_buffer_info (char *bufline, BUFFER_INFO *);
int parse_process_info (char *procline, PROCESS_INFO *);
int check_buffer_info (BUFFER_INFO * bi);
int check_process_info (PROCESS_INFO * bi);
int nmlcfg_write_output (char *filename);
int add_nmlcfg_var (char *line);
int replace_defined_variables (char *line);
VAR_INFO temp_var_info;
BUFFER_INFO default_buffer;
RCS_LINKED_LIST buffer_list;
PROCESS_INFO default_process;
RCS_LINKED_LIST process_list;
RCS_LINKED_LIST var_list;
RCS_LINKED_LIST file_list;
RCS_LINKED_LIST include_dir_list;
RCS_LINKED_LIST comments;
char temp_dir[256];
char temp_file[256];
char output_file[256];
int nmlcfg_verbose = 0;
char unknown_config_file[] = "UNKNOWN";
char *current_config_file = unknown_config_file;
int linenum = 0;
BUFFER_INFO temp_buffer_info;
PROCESS_INFO temp_process_info;
int inverse_mode = 0;

char remote_port_name[6][6] = {
  "NONE",
  "RPC",
  "TTY",
  "TCP",
  "STCP",
  "UDP"
};


char buf_type_name[7][8] = {
  "SHMEM",
  "GLOBMEM",
  "PHANTOM",
  "LOCMEM",
  "FILEMEM",
  "BBDMEM",
  "RTLMEM"
};


char proc_type_name[4][8] = {
  "REMOTE",
  "LOCAL",
  "PHANTOM",
  "AUTO"
};



BUFFER_INFO::BUFFER_INFO ()
{
  initialize ();
}

void
BUFFER_INFO::initialize ()
{
  memset (name, 0, 80);
  memset (host, 0, 80);
  brpi = -1.0;
  strcpy (host, "localhost");
  buftype = CMS_SHMEM_TYPE;
  size = 960;
  neut = 0;
  oldstyle = 0;
  buffer_number = 1;
  shmem_key = 10001;
  bsem_key = -1;
  max_proc = -1;
  vme_addr = 0;
  remotetype = CMS_TCP_REMOTE_PORT_TYPE;
  remote_port = 30000;
  encoding_type = CMS_XDR_ENCODING;
  queue = 0;
  use_autocnum = 0;
  memset (endline, 0, 80);
  comment_num = 0;
  force_type = -1;
  bbd_size = 0;
  enable_diag = 0;
}


PROCESS_INFO::PROCESS_INFO ()
{
  initialize ();
}

void
PROCESS_INFO::initialize ()
{
  memset (name, 0, 80);
  memset (host, 0, 80);
  strcpy (host, "localhost");
  memset (bufname, 0, 80);
  oldstyle = 0;
  buf_info = NULL;
  proctype = CMS_REMOTE_TYPE;
  isserver = 0;
  timeout = -1.0;
  subscription_interval = -1.0;
  retry_interval = -1.0;
  master = 0;
  c_num = -1;
  memset (endline, 0, 80);
  comment_num = -1;
  ops = READ_WRITE;
}

VAR_INFO::VAR_INFO ()
{
  namelen = 0;
  vallen = 0;
  memset (name, 0, 80);
  memset (val, 0, 80);
}

int warn = 1;

int
main (int argc, char **argv)
{
  strcpy (output_file, "stdout");
  memset (temp_file, 0, 256);

  if (argc < 1)
    {
      fprintf (stderr,
               "nmlcfg usage: [-D name=val] [-I dir] [-o output_file] files . . .\n");
      exit (-1);
    }

  char flag = 0;

  for (int i = 1; i < argc; i++)
    {
      if (!strcmp (argv[i], "-inverse"))
        {
          inverse_mode = 1;
          continue;
        }
      if (argv[i][0] == '-')
        {
          flag = argv[i][1];
          switch (flag)
            {
            case 'w':
              warn = 0;
              flag = 0;
              break;

            case 'W':
              flag = 0;
              warn = 1;
              break;

            case 'v':
              nmlcfg_verbose = 1;
              flag = 0;
              break;

            default:
              break;
            }
          continue;
        }
      switch (flag)
        {

        case 'o':
          strncpy (output_file, argv[i], 256);
          // rcs_print("output_file=%s\n",output_file);
          break;

        case 'D':
          {
            char *eq = strstr (argv[i], "=");
            if (eq != NULL)
              {
                *eq = 0;
                strncpy (temp_var_info.name, argv[i], 80);
                strncpy (temp_var_info.val, eq + 1, 80);
                // rcs_print("(%s)=(%s)\n",temp_var_info.name, temp_var_info.val);
                temp_var_info.namelen = strlen (temp_var_info.name);
                temp_var_info.vallen = strlen (temp_var_info.val);
                var_list.store_at_tail (&temp_var_info, sizeof (VAR_INFO), 0);
              }
          }
          break;

        case 'I':
          strncpy (temp_dir, argv[i], 256);
          include_dir_list.store_at_tail (temp_dir, 256, 1);
          break;

        case 0:
          strncpy (temp_file, argv[i], 256);
          file_list.store_at_tail (temp_file, 256, 1);
          break;

        default:
          fprintf (stderr,
                   "nmlcfg usage: [-D name=val] [-I dir] [-o output_file] files . . .\n");
          exit (-1);
          break;
        }
      flag = 0;
    }
  if (file_list.list_size < 1)
    {
      fprintf (stderr,
               "nmlcfg usage: [-D name=val] [-I dir] [-o output_file] files . . .\n");
      exit (-1);
    }

  char *filename = (char *) file_list.get_head ();
  while (filename != NULL)
    {
      nmlcfg_read_file (filename);
      filename = (char *) file_list.get_next ();
    }
  nmlcfg_write_output (output_file);
}

int last_line_blank = 0;

int
nmlcfg_read_file (char *filename)
{
  char line[256];
  int linelen = 0;
  FILE *fp = NULL;
  char *include_dir;
  char tempfile[256];
  int templinenum;

  fp = fopen (filename, "r");
  if (NULL == fp)
    {
      include_dir = (char *) include_dir_list.get_head ();
      while (fp == NULL && include_dir != NULL)
        {
          strncpy (tempfile, include_dir, 256);
          strcat (tempfile, "/");
          strcat (tempfile, filename);
          fp = fopen (filename, "r");
        }
    }
  else
    {
      strncpy (tempfile, filename, 256);
    }
  current_config_file = tempfile;
  linenum = templinenum = 0;
  if (NULL == fp)
    {
      fprintf (stderr, "Can't open file %s.\n", filename);
      exit (-1);
    }
  while (!feof (fp))
    {
      memset (line, 0, 256);
      if (NULL == fgets (line, 256, fp))
        {
          fclose (fp);
          return 0;
        }
      templinenum++;
      linenum = templinenum;
      linelen = strlen (line);
      if (linelen < 1)
        {
          continue;
        }
      while (linelen > 0)
        {
          if (line[linelen - 1] == '\r' ||
              line[linelen - 1] == '\n' ||
              line[linelen - 1] == '\t' || line[linelen - 1] == ' ')
            {
              line[linelen - 1] = 0;
              linelen--;
              continue;
            }
          if (line[linelen - 1] == '\\')
            {
              line[linelen - 1] = 0;
              linelen--;
              if (NULL == fgets (line + linelen, 256 - linelen, fp))
                {
                  fclose (fp);
                  return 0;
                }
              templinenum++;
              linenum = templinenum;
              linelen = strlen (line);
              continue;
            }
          break;
        }
      if (nmlcfg_verbose)
        {
          printf ("%d %s\n", linenum, line);
        }
      if (linelen < 1)
        {
          if (!last_line_blank)
            {
              comments.store_at_tail ((void *) " ", 2, 1);
            }
          last_line_blank = 1;
          continue;
        }
      replace_defined_variables (line);
      if (line[0] == '#')
        {
          if (line[1] == '#')
            {
              last_line_blank = 0;
              comments.store_at_tail (line + 1, 255, 1);
            }
          continue;
        }
      if (!strncmp (line, "buffer_default", 14)
          || !strncmp (line, "BUFFER_DEFAULT", 14))
        {
          parse_buffer_info (line, &default_buffer);
          continue;
        }
      if (!strncmp (line, "process_default", 14)
          || !strncmp (line, "PROCESS_DEFAULT", 14))
        {
          parse_process_info (line, &default_process);
          continue;
        }
      if (!strncmp (line, "include", 7) || !strncmp (line, "INCLUDE", 7))
        {
          char *fnptr = line + 7;
          while (*fnptr == ' ' || *fnptr == '\t')
            {
              fnptr++;
            }
          nmlcfg_read_file (fnptr);
          current_config_file = tempfile;
          continue;
        }
      if (!strncmp (line, "define", 6) || !strncmp (line, "DEFINE", 6))
        {
          add_nmlcfg_var (line);
          continue;
        }
      last_line_blank = 0;
      if (line[0] == 'b' || line[0] == 'B')
        {
          temp_buffer_info.initialize ();
          strcpy (temp_buffer_info.host, default_buffer.host);
          temp_buffer_info.buftype = default_buffer.buftype;
          temp_buffer_info.size = default_buffer.size;
          temp_buffer_info.brpi = default_buffer.brpi;
          temp_buffer_info.neut = default_buffer.neut;
          temp_buffer_info.buffer_number = default_buffer.buffer_number;
          temp_buffer_info.shmem_key = default_buffer.shmem_key;
          temp_buffer_info.bsem_key = default_buffer.bsem_key;
          temp_buffer_info.max_proc = default_buffer.max_proc;
          temp_buffer_info.vme_addr = default_buffer.vme_addr;
          temp_buffer_info.remotetype = default_buffer.remotetype;
          temp_buffer_info.remote_port = default_buffer.remote_port;
          temp_buffer_info.encoding_type = default_buffer.encoding_type;
          temp_buffer_info.queue = default_buffer.queue;
          temp_buffer_info.enable_diag = default_buffer.enable_diag;
          temp_buffer_info.use_autocnum = default_buffer.use_autocnum;
          temp_buffer_info.comment_num = comments.list_size;
          parse_buffer_info (line, &temp_buffer_info);
          temp_buffer_info.orig_size = temp_buffer_info.size;
          if (!temp_buffer_info.oldstyle)
            {
              if (temp_buffer_info.queue > 1)
                {
                  temp_buffer_info.size *= temp_buffer_info.queue;
                  temp_buffer_info.size += temp_buffer_info.queue * 12;
                }
              if (temp_buffer_info.queue)
                {
                  temp_buffer_info.size += 20;
                }
              temp_buffer_info.size += 64;
              if (temp_buffer_info.size % 64)
                {
                  temp_buffer_info.size +=
                    (64 - (temp_buffer_info.size % 64));
                }
              if (temp_buffer_info.buftype == CMS_GLOBMEM_TYPE
                  && temp_buffer_info.enable_diag)
                {
                  if (temp_buffer_info.max_proc > 1)
                    {
                      temp_buffer_info.size +=
                        144 * temp_buffer_info.max_proc;
                    }
                  else
                    {
                      // This assumes only 5 buffers connect.
                      temp_buffer_info.size += 720;
                    }
                }

            }
          check_buffer_info (&temp_buffer_info);
          strcat (temp_buffer_info.endline, default_buffer.endline);
          buffer_list.store_at_tail (&temp_buffer_info, sizeof (BUFFER_INFO),
                                     1);
          if (!temp_buffer_info.oldstyle)
            {
              if (temp_buffer_info.buftype == CMS_GLOBMEM_TYPE
                  && default_buffer.vme_addr > 0)
                {
                  default_buffer.vme_addr += temp_buffer_info.size;
                }
              if (temp_buffer_info.buftype == CMS_SHMEM_TYPE)
                {
                  default_buffer.shmem_key++;
                  if (default_buffer.bsem_key > 0)
                    {
                      default_buffer.bsem_key++;
                    }
                }
              default_buffer.buffer_number++;
            }
          continue;
        }
      if (line[0] == 'p' || line[0] == 'P')
        {
          temp_process_info.initialize ();
          strcpy (temp_process_info.host, default_process.host);
          strcpy (temp_process_info.name, default_process.name);
          strcpy (temp_process_info.bufname, default_process.bufname);
          temp_process_info.proctype = default_process.proctype;
          temp_process_info.subscription_interval =
            default_process.subscription_interval;
          temp_process_info.retry_interval = default_process.retry_interval;
          temp_process_info.timeout = default_process.timeout;
          temp_process_info.c_num = default_process.c_num;
          temp_process_info.isserver = default_process.isserver;
          temp_process_info.master = default_process.master;
          temp_process_info.ops = default_process.ops;
          temp_process_info.comment_num = comments.list_size;
          parse_process_info (line, &temp_process_info);
          check_process_info (&temp_process_info);
          strcat (temp_process_info.endline, default_process.endline);
          process_list.store_at_tail (&temp_process_info,
                                      sizeof (PROCESS_INFO), 1);
          continue;
        }
      rcs_print_error ("%s:%d: Line of config file was not recognized.\n",
                       current_config_file, linenum);
      rcs_print_error ("%s:%d: -->%s\n", current_config_file, linenum, line);
    }
  fclose (fp);
  current_config_file = unknown_config_file;
  return (0);
}


int
replace_defined_variables (char *line)
{
  char temp_line[256];
  memset (temp_line, 0, 256);
  strncpy (temp_line, line, 256);
  char *cptr = temp_line;
  char *lptr = line;
  while (*cptr)
    {
      if (*cptr == '$')
        {
          cptr++;
          int varname_len = 1;
          char *vptr = cptr + 1;
          int used_parens = 0;
          if (*cptr == '(')
            {
              cptr++;
              used_parens = 1;
              vptr++;
              while (*vptr != ')')
                {
                  varname_len++;
                  if (*vptr == 0 || *vptr == '\n' || *vptr == '\r')
                    {
                      fprintf (stderr, "Bad variable reference %s:%d.\n",
                               current_config_file, linenum);
                      return (-1);
                    }
                  vptr++;
                }
            }
          else
            {
              while (*vptr != 0 && *vptr != ' ' && *vptr != '\t'
                     && *vptr != '\n' && *vptr != '\r')
                {
                  varname_len++;
                  vptr++;
                }
            }
          VAR_INFO *vi = (VAR_INFO *) var_list.get_head ();
          while (vi != NULL)
            {
              if (vi->namelen == varname_len)
                {
                  if (!strncmp (cptr, vi->name, vi->namelen))
                    {
                      strcpy (lptr, vi->val);
                      lptr += vi->vallen;
                      cptr += vi->namelen;
                      if (used_parens)
                        {
                          cptr++;
                        }
                      break;
                    }
                }
              vi = (VAR_INFO *) var_list.get_next ();
            }
          if (NULL == vi)
            {
              char *endname_ptr = cptr;
              while (*endname_ptr != ' ' && *endname_ptr != 0
                     && *endname_ptr != '\t')
                {
                  endname_ptr++;
                }
              *endname_ptr = 0;
              fprintf (stderr, "Variable %s on line %d of %s is undefined.\n",
                       cptr, linenum, current_config_file);
              exit (-1);
            }
        }
      *lptr = *cptr;
      cptr++;
      lptr++;
    }
  *lptr = 0;
  return (0);
}

int
add_nmlcfg_var (char *line)
{
  char *var_ptr = line + 6;
  while (*var_ptr == ' ' || *var_ptr == '\t')
    {
      var_ptr++;
    }
  char *val_ptr = var_ptr;
  while (*val_ptr != '=')
    {
      if (0 == *val_ptr)
        {
          return -1;
        }
      val_ptr++;
    }
  *val_ptr = 0;
  val_ptr++;
  char *end_var_ptr = val_ptr - 2;
  while (*end_var_ptr == ' ' || *end_var_ptr == '\t')
    {
      if (var_ptr >= end_var_ptr)
        {
          return -1;
        }
      *end_var_ptr = 0;
      end_var_ptr--;
    }

  while (*var_ptr == ' ' || *var_ptr == '\t')
    {
      var_ptr++;
    }
  strncpy (temp_var_info.val, val_ptr, 80);
  strncpy (temp_var_info.name, var_ptr, 80);
  temp_var_info.namelen = strlen (temp_var_info.name);
  temp_var_info.vallen = strlen (temp_var_info.val);
  var_list.store_at_tail (&temp_var_info, sizeof (VAR_INFO), 1);
  return (0);
}


int
check_process_info (PROCESS_INFO * pi_to_check)
{
  BUFFER_INFO *bi = (BUFFER_INFO *) buffer_list.get_head ();
  while (NULL != bi)
    {
      if (!strcmp (bi->name, pi_to_check->bufname))
        {
          break;
        }
      bi = (BUFFER_INFO *) buffer_list.get_next ();
    }
  if (NULL == bi)
    {
      if (!strcmp (pi_to_check->bufname, "default"))
        {
          bi = &default_buffer;
        }
      else
        {
          rcs_print_error
            ("%s:%d: There is no buffer line for %s, but the process %s is configured to connect to it.\n",
             current_config_file, linenum, pi_to_check->bufname,
             pi_to_check->name);
          return (-1);
        }
    }
  if (pi_to_check->c_num < 0)
    {
      pi_to_check->c_num = bi->processes_connected;
    }
  PROCESS_INFO *pi = (PROCESS_INFO *) bi->proc_list.get_head ();
  while (NULL != pi)
    {
      if (warn)
        {
          if (pi->master && pi_to_check->master)
            {
              rcs_print
                ("%s:%d: Warning: Both %s and %s are masters for %s\n",
                 current_config_file, linenum, pi->name, pi_to_check->name,
                 bi->name);
            }
          if (pi->isserver && pi_to_check->isserver)
            {
              rcs_print
                ("%s:%d: Warning: Both %s and %s are servers for %s\n",
                 current_config_file, linenum, pi->name, pi_to_check->name,
                 bi->name);
            }
          if (pi->c_num == pi_to_check->c_num)
            {
              rcs_print
                ("%s:%d: Warning: Both %s and %s have the same c_num(%d) for buffer %s.\n",
                 current_config_file, linenum, pi->name, pi_to_check->name,
                 pi->c_num, bi->name);
            }
        }
      pi = (PROCESS_INFO *) bi->proc_list.get_next ();
    }
  bi->processes_connected++;
  bi->proc_list.store_at_tail (pi_to_check, sizeof (PROCESS_INFO), 1);
  if (pi_to_check->c_num >= bi->max_proc && bi->max_proc > 0)
    {
      if (warn)
        {
          rcs_print
            ("%s:%d: Warning: Process %s has a c_num of %d which is greater that the maximum processes allowed of %d for buffer %s\n",
             current_config_file, linenum, pi_to_check->name,
             pi_to_check->c_num, bi->max_proc, bi->name);
        }
    }
  return (0);
}



int
check_buffer_info (BUFFER_INFO * bi_to_check)
{
  BUFFER_INFO *bi = (BUFFER_INFO *) buffer_list.get_head ();
  while (bi != NULL)
    {
      bi->bufline_line_number = linenum;
      if (!strcmp (bi_to_check->name, bi->name))
        {
          rcs_print_error ("%s:%d: Error: More than one buffer line for %s\n",
                           current_config_file, linenum, bi->name);
          exit (-1);
          break;
        }
      if (bi_to_check->buffer_number == bi->buffer_number)
        {
          if (warn)
            {
              rcs_print
                ("%s:%d: Warning %s and %s both have buffer_number %d\n",
                 current_config_file, linenum, bi->name, bi_to_check->name,
                 bi->buffer_number);
            }
          return (-1);
        }
      if (bi_to_check->buftype != bi->buftype)
        {
          bi = (BUFFER_INFO *) buffer_list.get_next ();
          continue;
        }
      if (bi->buftype == CMS_SHMEM_TYPE)
        {
          if (bi->shmem_key == bi_to_check->shmem_key)
            {
              if (warn)
                {
                  rcs_print
                    ("%s:%d: Warning: %s and %s both have shared mem key %d\n",
                     current_config_file, linenum, bi->name,
                     bi_to_check->name, bi->shmem_key);
                }
              return (-1);
            }
          if (bi->bsem_key == bi_to_check->bsem_key && bi->bsem_key > 0)
            {
              if (warn)
                {
                  rcs_print
                    ("%s:%d: Warning: %s and %s both have blocking semaphore key %d\n",
                     current_config_file, linenum, bi->name,
                     bi_to_check->name, bi->bsem_key);
                }
              return (-1);
            }
          if (bi->bsem_key == bi_to_check->shmem_key)
            {
              if (warn)
                {
                  rcs_print
                    ("%s:%d: Warning: The blocking semaphore key of %s conflicts with the shared memory key of %s which both equal %d\n",
                     current_config_file, linenum, bi->name,
                     bi_to_check->name, bi->bsem_key);
                }
              return (-1);
            }
          if (bi->shmem_key == bi_to_check->bsem_key)
            {
              if (warn)
                {
                  rcs_print
                    ("%s:%d: Warning: The blocking semaphore key of %s conflicts with the shared memory key of %s which both equal %d\n",
                     current_config_file, linenum, bi_to_check->name,
                     bi->name, bi->shmem_key);
                }
              return (-1);
            }
        }
      if (bi->buftype == CMS_GLOBMEM_TYPE)
        {
          if (bi_to_check->vme_addr <= 0 && !bi_to_check->oldstyle)
            {
              if (warn)
                {
                  rcs_print
                    ("%s:%d: Warning the VME address of %s is less than or equal to zero.\n",
                     current_config_file, linenum, bi_to_check->name);
                }
              return (-1);
            }
          if (bi->vme_addr > 0)
            {
              if (bi->vme_addr >= bi_to_check->vme_addr
                  && bi->vme_addr < bi_to_check->vme_addr + bi_to_check->size)
                {
                  if (warn)
                    {
                      rcs_print
                        ("%s:%d: Warning: Buffers %s and %s seem to have conflicting VME addresses at 0x%X and 0x%X and a size of %d.\n",
                         current_config_file, linenum, bi->name,
                         bi_to_check->name, bi->vme_addr,
                         bi_to_check->vme_addr, bi_to_check->size);
                    }
                  return (-1);
                }
              if (bi_to_check->vme_addr >= bi->vme_addr
                  && bi_to_check->vme_addr < bi->vme_addr + bi->size)
                {
                  if (warn)
                    {
                      rcs_print
                        ("%s:%d: Warning: Buffers %s and %s seem to have conflicting VME addresses at 0x%X and 0x%X and a size of %d.\n",
                         current_config_file, linenum, bi_to_check->name,
                         bi->name, bi_to_check->vme_addr, bi->vme_addr,
                         bi->size);
                    }
                  return (-1);
                }
            }
        }
      bi = (BUFFER_INFO *) buffer_list.get_next ();
    }
  return 0;
}

int
parse_buffer_info (char *bufline, BUFFER_INFO * bi)
{
  char *word[32];
  bi->oldstyle = (NULL == strstr (bufline, "name="))
    && (NULL == strstr (bufline, "default"));
  int num_words = separate_words (word, 32, bufline);
  if (bi->oldstyle)
    {
      if (num_words < 9)
        {
          rcs_print_error ("%s:%d Invalid line\n",
                           current_config_file, linenum);
          return -1;
        }
      bi->queue = 0;
      bi->use_autocnum = 0;
      bi->enable_diag = 0;
      bi->bsem_key = -1;
      strcpy (bi->name, word[1]);
      strcpy (bi->host, word[3]);
      char *buffer_type_name = word[2];
      /* Determine the BufferType. */
      if (!strcmp (buffer_type_name, "SHMEM"))
        {
          bi->buftype = CMS_SHMEM_TYPE;
        }
      else if (!strcmp (buffer_type_name, "GLOBMEM"))
        {
          bi->buftype = CMS_GLOBMEM_TYPE;
        }
      else if (!strcmp (buffer_type_name, "BBDMEM"))
        {
          bi->buftype = CMS_BBDMEM_TYPE;
        }
      else if (!strcmp (buffer_type_name, "PHANTOM"))
        {
          bi->buftype = CMS_PHANTOM_BUFFER;
        }
      else if (!strcmp (buffer_type_name, "LOCMEM"))
        {
          bi->buftype = CMS_LOCMEM_TYPE;
        }
      else if (!strcmp (buffer_type_name, "FILEMEM"))
        {
          bi->buftype = CMS_FILEMEM_TYPE;
        }
      else
        {
          rcs_print_error ("%s:%d: CMS: invalid buffer type (%s)\n",
                           current_config_file, linenum, buffer_type_name);
          exit (-1);
        }

      bi->size = (long) atol (word[4]);
      bi->neut = (int) atol (word[5]);
      bi->buffer_number = atol (word[7]);
      bi->max_proc = atol (word[8]);
      memset (bi->endline, 0, 80);
      int last_word = 9;
      if (bi->buftype == CMS_SHMEM_TYPE)
        {
          bi->shmem_key = atol (word[9]);
          last_word = 10;
        }
      for (int i = last_word; i < num_words - 1; i++)
        {
          if (NULL == word[i])
            {
              break;
            }
          strcat (bi->endline, " ");
          strcat (bi->endline, word[i]);
        }
    }
  else
    {
      for (int i = 1; i < num_words - 1; i++)
        {
          if (NULL == word[i])
            {
              break;
            }

          if (!strncmp (word[i], "bufname=", 8)
              || !strncmp (word[i], "BUFNAME=", 8))
            {
              strncpy (bi->name, ((char *) word[i]) + 8, 80);
              continue;
            }
          if (!strncmp (word[i], "name=", 5)
              || !strncmp (word[i], "NAME=", 5))
            {
              strncpy (bi->name, ((char *) word[i]) + 5, 80);
              continue;
            }
          if (!strncmp (word[i], "bufhost=", 8)
              || !strncmp (word[i], "BUFHOST=", 8))
            {
              strncpy (bi->host, ((char *) word[i]) + 8, 80);
              continue;
            }
          if (!strncmp (word[i], "host=", 5)
              || !strncmp (word[i], "HOST=", 5))
            {
              strncpy (bi->host, ((char *) word[i]) + 5, 80);
              continue;
            }
          if (!strncmp (word[i], "buftype=", 8)
              || !strncmp (word[i], "BUFTYPE=", 8))
            {
              char *buffer_type_name = ((char *) word[i]) + 8;
              if (!strncmp (buffer_type_name, "SHMEM", 5) ||
                  !strncmp (buffer_type_name, "shmem", 5))
                {
                  bi->buftype = CMS_SHMEM_TYPE;
                }
              else if (!strcmp (buffer_type_name, "GLOBMEM") ||
                       !strcmp (buffer_type_name, "globmem"))
                {
                  bi->buftype = CMS_GLOBMEM_TYPE;
                }
              else if (!strcmp (buffer_type_name, "BBDMEM") ||
                       !strcmp (buffer_type_name, "bbdmem") ||
                       !strcmp (buffer_type_name, "BBD") ||
                       !strcmp (buffer_type_name, "bbd"))
                {
                  bi->buftype = CMS_BBDMEM_TYPE;
                }
              else if (!strcmp (buffer_type_name, "PHANTOM") ||
                       !strcmp (buffer_type_name, "phantom"))
                {
                  bi->buftype = CMS_PHANTOM_BUFFER;
                }
              else if (!strcmp (buffer_type_name, "LOCMEM") ||
                       !strcmp (buffer_type_name, "locmem"))
                {
                  bi->buftype = CMS_LOCMEM_TYPE;
                }
              else if (!strcmp (buffer_type_name, "FILEMEM") ||
                       !strcmp (buffer_type_name, "filemem"))
                {
                  bi->buftype = CMS_FILEMEM_TYPE;
                }
              else
                {
                  rcs_print_error
                    ("%s:%d: CMS Invalid buffer type (%s) on line %d of %s\n",
                     current_config_file, linenum, buffer_type_name);
                  exit (-1);
                }
              continue;
            }
          if (!strncmp (word[i], "size=", 5)
              || !strncmp (word[i], "SIZE=", 5))
            {
              bi->size = strtoul (((char *) word[i]) + 5, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "brpi=", 5)
              || !strncmp (word[i], "BRPI=", 5))
            {
              bi->brpi = strtod (((char *) word[i]) + 5, NULL);
              continue;
            }
          if (!strncmp (word[i], "bbd_size=", 9)
              || !strncmp (word[i], "BBD_SIZE=", 9))
            {
              bi->bbd_size = strtol (((char *) word[i]) + 9, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "force_type=", 11)
              || !strncmp (word[i], "force_type=", 11))
            {
              bi->force_type = strtol (((char *) word[i]) + 11, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "neut=", 5)
              || !strncmp (word[i], "NEUT=", 5))
            {
              bi->neut = is_true (((char *) word[i]) + 5);
              continue;
            }
          if (!strncmp (word[i], "neutral=", 8)
              || !strncmp (word[i], "NEUTRAL=", 8))
            {
              bi->neut = is_true (((char *) word[i]) + 8);
              continue;
            }
          if (!strncmp (word[i], "buffer_number=", 14)
              || !strncmp (word[i], "BUFFER_NUMBER=", 14))
            {
              bi->buffer_number = strtol (((char *) word[i]) + 5, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "bufnumber=", 10)
              || !strncmp (word[i], "BUFNUMBER=", 10))
            {
              bi->buffer_number = strtol (((char *) word[i]) + 10, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "bufnumber=", 10)
              || !strncmp (word[i], "BUFNUMBER=", 10))
            {
              bi->buffer_number = strtol (((char *) word[i]) + 10, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "key=", 4) || !strncmp (word[i], "KEY=", 4))
            {
              bi->shmem_key = strtol (((char *) word[i]) + 4, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "bsem=", 5)
              || !strncmp (word[i], "BSEM=", 5))
            {
              bi->bsem_key = strtol (((char *) word[i]) + 5, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "max_proc=", 9)
              || !strncmp (word[i], "MAX_PROC=", 9))
            {
              bi->max_proc = strtol (((char *) word[i]) + 9, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "vme_addr=", 9)
              || !strncmp (word[i], "VME_ADDR=", 9))
            {
              bi->vme_addr = strtoul (((char *) word[i]) + 9, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "remotetype=", 11)
              || !strncmp (word[i], "REMOTETYPE=", 11))
            {
              char *remote_type_name = ((char *) word[i]) + 11;
              if (!strncmp (remote_type_name, "tcp", 3) ||
                  !strncmp (remote_type_name, "TCP", 3))
                {
                  bi->remotetype = CMS_TCP_REMOTE_PORT_TYPE;
                }
              else if (!strncmp (remote_type_name, "udp", 3) ||
                       !strncmp (remote_type_name, "UDP", 3))
                {
                  bi->remotetype = CMS_UDP_REMOTE_PORT_TYPE;
                }
              else if (!strncmp (remote_type_name, "stcp", 4) ||
                       !strncmp (remote_type_name, "STCP", 4))
                {
                  bi->remotetype = CMS_STCP_REMOTE_PORT_TYPE;
                }
              else
                {
                  rcs_print_error ("%s:%d: Remote type not recognized %s\n",
                                   current_config_file, linenum,
                                   remote_type_name);
                  exit (-1);
                }
              continue;
            }
          if (!strncmp (word[i], "remote_port=", 13)
              || !strncmp (word[i], "REMOTE_PORT=", 13))
            {
              bi->remote_port = strtol (((char *) word[i]) + 13, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "port=", 5)
              || !strncmp (word[i], "PORT=", 5))
            {
              bi->remote_port = strtol (((char *) word[i]) + 5, NULL, 0);
              continue;
            }
          char *encoding_type_name = NULL;
          if (!strncmp (word[i], "enc=", 4) || !strncmp (word[i], "ENC=", 4))
            {
              encoding_type_name = ((char *) word[i]) + 4;
            }
          else if (!strncmp (word[i], "encoding_type=", 14)
                   || !strncmp (word[i], "ENCODING_TYPE=", 14))
            {
              encoding_type_name = ((char *) word[i]) + 14;
            }
          if (NULL != encoding_type_name)
            {
              if (!strncmp (encoding_type_name, "xdr", 3) ||
                  !strncmp (encoding_type_name, "XDR", 3))
                {
                  bi->encoding_type = CMS_XDR_ENCODING;
                }
              else if (!strncmp (encoding_type_name, "ascii", 5) ||
                       !strncmp (encoding_type_name, "ASCII", 5))
                {
                  bi->encoding_type = CMS_DISPLAY_ASCII_ENCODING;
                }
              else if (!strncmp (encoding_type_name, "disp", 4) ||
                       !strncmp (encoding_type_name, "DISP", 4))
                {
                  bi->encoding_type = CMS_DISPLAY_ASCII_ENCODING;
                }
              else if (!strncmp (encoding_type_name, "display", 7) ||
                       !strncmp (encoding_type_name, "DISPLAY", 7))
                {
                  bi->encoding_type = CMS_DISPLAY_ASCII_ENCODING;
                }
              else
                {
                  rcs_print_error
                    ("%s:%d: Unknown encoding type %d on line %d of %s\n",
                     current_config_file, linenum, encoding_type_name);
                  exit (-1);
                }
              continue;
            }
          if (!strncmp (word[i], "queue=", 6)
              || !strncmp (word[i], "QUEUE=", 6))
            {
              bi->queue = is_true (((char *) word[i]) + 6);
              continue;
            }
          if (!strncmp (word[i], "diag=", 5)
              || !strncmp (word[i], "DIAG=", 5))
            {
              bi->enable_diag = is_true (((char *) word[i]) + 5);
              continue;
            }
          if (!strncmp (word[i], "autocnum=", 9)
              || !strncmp (word[i], "AUTOCNUM=", 9))
            {
              bi->use_autocnum = is_true (((char *) word[i]) + 9);
              continue;
            }
          if (strncmp (word[i], "retry=", 6))
            {
              if (warn)
                {
                  rcs_print ("%s:%d: Warning: %s not recognized.\n",
                             current_config_file, linenum, word[i]);
                }
            }
          strcat (bi->endline, " ");
          strcat (bi->endline, word[i]);
        }
    }
  return (0);
}



int
parse_process_info (char *bufline, PROCESS_INFO * pi)
{
  static int bad_cnums = 0;
  char *word[32];
  pi->oldstyle = (NULL == strstr (bufline, "name="))
    && (NULL == strstr (bufline, "default"));
  int num_words = separate_words (word, 32, bufline);
  if (pi->oldstyle)
    {
      if (num_words < 10)
        {
          rcs_print_error ("%s:%d: Invalid line\n",
                           current_config_file, linenum);
          return -1;
        }
      pi->subscription_interval = 0;
      pi->retry_interval = 0;
      strcpy (pi->name, word[1]);
      if (!strncmp (pi->name, "default", 7))
        {
          default_lines_detected = 1;
        }
      strcpy (pi->bufname, word[2]);
      if (!strncmp (pi->bufname, "default", 7))
        {
          default_lines_detected = 1;
        }
      strcpy (pi->host, word[4]);
      char *process_type_name = word[3];
      /* Determine the ProcessType. */
      if (!strcmp (process_type_name, "REMOTE"))
        {
          pi->proctype = CMS_REMOTE_TYPE;
        }
      else if (!strcmp (process_type_name, "LOCAL"))
        {
          pi->proctype = CMS_LOCAL_TYPE;
        }
      else if (!strcmp (process_type_name, "PHANTOM"))
        {
          pi->proctype = CMS_PHANTOM_USER;
        }
      else if (!strcmp (process_type_name, "AUTO"))
        {
          pi->proctype = CMS_AUTO_TYPE;
        }
      else
        {
          rcs_print_error ("%s:%d: CMS: invalid process type (%s)\n",
                           current_config_file, linenum, process_type_name);
          exit (-1);
        }
      pi->ops = NO_OPS;
      if (strstr (word[5], "R") != NULL)
        {
          pi->ops = READ_ONLY;
        }
      if (strstr (word[5], "W") != NULL)
        {
          if (pi->ops == READ_ONLY)
            {
              pi->ops = READ_WRITE;
            }
          else
            {
              pi->ops = WRITE_ONLY;
            }
        }
      pi->isserver = atol (word[6]);
      if (!strcmp (word[7], "INF"))
        {
          pi->timeout = -1.0;
        }
      else
        {
          pi->timeout = strtod (word[7], NULL);
        }
      if (NULL != word[8])
        {
          pi->master = atol (word[8]);
        }
      if (word[9] != NULL)
        {
          pi->c_num = atol (word[9]);
        }
      else
        {
          pi->c_num = ++bad_cnums;
        }
      memset (pi->endline, 0, 80);
      int last_word = 10;
      for (int i = last_word; i < num_words - 1; i++)
        {
          if (NULL == word[i])
            {
              break;
            }
          strcat (pi->endline, " ");
          strcat (pi->endline, word[i]);
        }
    }
  else
    {
      for (int i = 1; i < num_words - 1; i++)
        {
          if (NULL == word[i])
            {
              break;
            }

          if (!strncmp (word[i], "bufname=", 8)
              || !strncmp (word[i], "BUFNAME=", 8))
            {
              strncpy (pi->bufname, ((char *) word[i]) + 8, 80);
              if (!strncmp (pi->bufname, "default", 7))
                {
                  default_lines_detected = 1;
                }
              continue;
            }
          if (!strncmp (word[i], "name=", 5)
              || !strncmp (word[i], "NAME=", 5))
            {
              strncpy (pi->name, ((char *) word[i]) + 5, 80);
              if (!strncmp (pi->name, "default", 7))
                {
                  default_lines_detected = 1;
                }
              continue;
            }
          if (!strncmp (word[i], "procname=", 9)
              || !strncmp (word[i], "PROCNAME=", 9))
            {
              strncpy (pi->name, ((char *) word[i]) + 9, 80);
              continue;
            }
          if (!strncmp (word[i], "prochost=", 9)
              || !strncmp (word[i], "PROCHOST=", 9))
            {
              strncpy (pi->host, ((char *) word[i]) + 9, 80);
              continue;
            }
          if (!strncmp (word[i], "host=", 5)
              || !strncmp (word[i], "HOST=", 5))
            {
              strncpy (pi->host, ((char *) word[i]) + 5, 80);
              continue;
            }
          if (!strncmp (word[i], "proctype=", 9)
              || !strncmp (word[i], "PROCTYPE=", 9))
            {
              char *process_type_name = ((char *) word[i]) + 9;
              if (!strncmp (process_type_name, "LOCAL", 5) ||
                  !strncmp (process_type_name, "local", 5))
                {
                  pi->proctype = CMS_LOCAL_TYPE;
                }
              else if (!strcmp (process_type_name, "REMOTE") ||
                       !strcmp (process_type_name, "remote"))
                {
                  pi->proctype = CMS_REMOTE_TYPE;
                }
              else if (!strcmp (process_type_name, "PHANTOM") ||
                       !strcmp (process_type_name, "phantom"))
                {
                  pi->proctype = CMS_PHANTOM_USER;
                }
              else if (!strcmp (process_type_name, "AUTO") ||
                       !strcmp (process_type_name, "auto"))
                {
                  pi->proctype = CMS_AUTO_TYPE;
                }
              else
                {
                  rcs_print_error ("%s:%d: CMS Invalid process type (%s)\n",
                                   current_config_file, linenum,
                                   process_type_name);
                  exit (-1);
                }
              continue;
            }
          if (!strncmp (word[i], "ops=", 4) || !strncmp (word[i], "OPS=", 4))
            {
              char *cops_ptr = word[i] + 4;
              pi->ops = NO_OPS;
              if (strstr (cops_ptr, "R") != NULL
                  || strstr (cops_ptr, "r") != NULL)
                {
                  pi->ops = READ_ONLY;
                }
              if (strstr (cops_ptr, "W") != NULL
                  || strstr (cops_ptr, "w") != NULL)
                {
                  if (pi->ops == READ_ONLY)
                    {
                      pi->ops = READ_WRITE;
                    }
                  else
                    {
                      pi->ops = WRITE_ONLY;
                    }
                }
              continue;
            }
          if (!strncmp (word[i], "timeout=", 8)
              || !strncmp (word[i], "TIMEOUT=", 8))
            {
              if (!strncmp (((char *) word[i]) + 8, "INF", 3)
                  || !strncmp (((char *) word[i]) + 8, "inf", 3))
                {
                  pi->timeout = -1.0;
                }
              else
                {
                  pi->timeout = strtod (((char *) word[i]) + 8, NULL);
                }
              continue;
            }
          if (!strncmp (word[i], "master=", 7)
              || !strncmp (word[i], "MASTER=", 7))
            {
              pi->master = is_true (((char *) word[i]) + 7);
              continue;
            }
          if (!strncmp (word[i], "server=", 7)
              || !strncmp (word[i], "SERVER=", 7))
            {
              pi->isserver = is_true (((char *) word[i]) + 7);
              continue;
            }
          if (!strncmp (word[i], "c_num=", 14)
              || !strncmp (word[i], "C_NUM=", 14))
            {
              pi->c_num = strtol (((char *) word[i]) + 5, NULL, 0);
              continue;
            }
          if (!strncmp (word[i], "sub=", 4) || !strncmp (word[i], "SUB=", 4))
            {
              pi->subscription_interval =
                strtod (((char *) word[i]) + 10, NULL);
              continue;
            }
          if (!strncmp (word[i], "retry=", 4)
              || !strncmp (word[i], "RETRY=", 4))
            {
              pi->retry_interval = strtod (((char *) word[i]) + 10, NULL);
              strcat (pi->endline, " ");
              strcat (pi->endline, word[i]);
              continue;
            }
          if (warn)
            {
              rcs_print ("%s:%d: Warning: %s not recognized.\n",
                         current_config_file, linenum, word[i]);
            }
          strcat (pi->endline, " ");
          strcat (pi->endline, word[i]);
        }
    }
  return (0);
}


int
is_true (char *str)
{
  if (str[0] == 'y' || str[0] == 'Y' || str[0] == 't' || str[0] == 'T')
    {
      return 1;
    }
  if (str[0] >= '0' && str[0] <= '9')
    {
      return atol (str);
    }
  return 0;
}



int
nmlcfg_write_output (char *filename)
{
  FILE *fp = NULL;
  int using_stdout = 0;

  if (!strcmp (filename, "stdout"))
    {
      printf ("\n\nOutput:\n");
      fp = stdout;
      using_stdout = 1;
    }
  else
    {
      fp = fopen (filename, "w");
    }
  if (NULL == fp)
    {
      rcs_print_error
        ("nmlcfg: error: Can't open %s for output (errno = %d:%s).\n",
         filename, errno, strerror (errno));
      exit (-1);
    }
  fprintf (fp, "# %s\n", filename);
  int first_buffer = 1;
  BUFFER_INFO *bi = (BUFFER_INFO *) buffer_list.get_head ();
  int comment_num = 0;
  char *comment = (char *) comments.get_head ();
  char line[256];
  memset (line, 0, 256);
  char last_host_name[80];
  CMS_BUFFERTYPE last_buftype = CMS_SHMEM_TYPE;
  strcpy (last_host_name, "localhost");
  int buffer_default_line_needed = 0;
  char default_buffer_line[80];
  char *bdl = default_buffer_line;
  memset (default_buffer_line, 0, 80);
  strcpy (default_buffer_line, "buffer_default ");
  int last_vme_addr = 0;
  while (bi != NULL)
    {
      while (comment != NULL && comment_num < bi->comment_num)
        {
          fprintf (fp, "%s\n", comment);
          comment = (char *) comments.get_next ();
          comment_num++;
        }
      if (first_buffer)
        {
          fprintf (fp, "\n# Buffers:\n");
          if (!inverse_mode)
            {
              fprintf (fp,
                       "# %10s \t%7.7s  \t%10s \tsize \tneut \t0 \tbuf# \tmax_proc \t. . .\n",
                       "name", "type", "host");
            }
        }
      first_buffer = 0;
      int orig_max_proc = bi->max_proc;
      if (bi->max_proc <= 0 && bi->processes_connected > 1)
        {
          bi->max_proc = bi->processes_connected + 1;
        }
      else if (bi->max_proc <= 0 && process_list.list_size > 1
               && process_list.list_size < 20)
        {
          bi->max_proc = process_list.list_size + 1;
        }
      else if (bi->max_proc <= 0)
        {
          bi->max_proc = 20;
        }
      if (bi->use_autocnum && default_lines_detected && bi->max_proc < 20)
        {
          bi->max_proc = 20;
        }
      if (bi->use_autocnum && !bi->oldstyle)
        {
          bi->size += 40 * bi->max_proc;
        }
      if (!bi->oldstyle && bi->enable_diag && bi->buftype != CMS_GLOBMEM_TYPE)
        {
          bi->size += 144 * bi->max_proc;
        }
      if (!bi->oldstyle && bi->enable_diag && bi->buftype == CMS_GLOBMEM_TYPE
          && bi->max_proc > 5 && orig_max_proc < 1)
        {
          rcs_print_error
            ("%s:%d Warning the size allocated for this buffer may not be enough to support %d processes and enable the logging of diagnostics data. It is suggested that you either specify max_proc, disable diagnostics, or increase the buffer size by %d.\n",
             current_config_file, bi->bufline_line_number, bi->max_proc,
             144 * (bi->max_proc - 5));
        }

      if (inverse_mode)
        {
          if (strcmp (last_host_name, bi->host))
            {
              buffer_default_line_needed = 1;
              bdl = default_buffer_line + strlen (default_buffer_line);
              sprintf (bdl, "host=%s ", bi->host);
              strcpy (last_host_name, bi->host);
            }
          if (last_buftype != bi->buftype)
            {
              buffer_default_line_needed = 1;
              bdl = default_buffer_line + strlen (default_buffer_line);
              sprintf (bdl, "buftype=%s ", buf_type_name[bi->buftype]);
              last_buftype = bi->buftype;
            }
          if (abs (bi->vme_addr - last_vme_addr) > 0x10000)
            {
              buffer_default_line_needed = 1;
              bdl = default_buffer_line + strlen (default_buffer_line);
              sprintf (bdl, "vme_addr=0x%X ", bi->vme_addr);
              last_vme_addr = bi->vme_addr;
            }
          if (buffer_default_line_needed)
            {
              buffer_default_line_needed = 0;
              fprintf (fp, "%s\n", default_buffer_line);
              memset (default_buffer_line, 0, 80);
              strcpy (default_buffer_line, "buffer_default ");
            }
          sprintf (line, "b name=%s ", bi->name);
          char *l;
          if (bi->size > 1024)
            {
              l = line + strlen (line);
              sprintf (l, "size=%d ", bi->size);
            }
          if (bi->neut)
            {
              l = line + strlen (line);
              sprintf (l, "neutral=1 ");
            }
          if (bi->queue)
            {
              l = line + strlen (line);
              sprintf (l, "queue=1 ");
            }
          if (bi->enable_diag)
            {
              l = line + strlen (line);
              sprintf (l, "diag=1 ");
            }
          if (bi->use_autocnum)
            {
              l = line + strlen (line);
              sprintf (l, "autocnum ");
            }
          if (bi->force_type > 0)
            {
              l = line + strlen (line);
              sprintf (l, "force_type=%d ", bi->force_type);
            }
          fprintf (fp, "%s\n", line);
        }
      else
        {
          if (bi->oldstyle)
            {
              switch (bi->buftype)
                {
                case CMS_SHMEM_TYPE:
                  sprintf (line,
                           "B %10s \tSHMEM    \t%10s \t%d \t%d \t0 \t%d \t%d \t%d \t%s",
                           bi->name, bi->host, bi->size, bi->neut,
                           bi->buffer_number, bi->max_proc, bi->shmem_key,
                           bi->endline);
                  break;

                default:
                  sprintf (line,
                           "B %10s \t%7.7s \t%10s \t%d \t%d \t0 \t%d \t%d \t%s",
                           bi->name, buf_type_name[bi->buftype], bi->host,
                           bi->size, bi->neut, bi->buffer_number,
                           bi->max_proc, bi->endline);
                  break;
                }
            }
          else
            {
              switch (bi->buftype)
                {
                case CMS_SHMEM_TYPE:
                  if (bi->bsem_key > 0)
                    {
                      sprintf (line,
                               "B %10s \tSHMEM    \t%10s \t%d \t%d \t0 \t%d \t%d \t%d \t%s=%d bsem=%d %10s",
                               bi->name, bi->host, bi->size, bi->neut,
                               bi->buffer_number, bi->max_proc, bi->shmem_key,
                               remote_port_name[bi->remotetype],
                               bi->remote_port, bi->bsem_key, bi->endline);
                    }
                  else
                    {
                      sprintf (line,
                               "B %10s \tSHMEM    \t%10s \t%d \t%d \t0 \t%d \t%d \t%d \t%s=%d %s",
                               bi->name, bi->host, bi->size, bi->neut,
                               bi->buffer_number, bi->max_proc, bi->shmem_key,
                               remote_port_name[bi->remotetype],
                               bi->remote_port, bi->endline);
                    }
                  break;

                case CMS_GLOBMEM_TYPE:
                  if (bi->vme_addr > 0)
                    {
                      sprintf (line,
                               "B %10s \tGLOBMEM \t%10s \t%d \t%d \t0 \t%d \t%d  \t%s=%d vme_addr=0x%lX %s",
                               bi->name, bi->host, bi->size, bi->neut,
                               bi->buffer_number, bi->max_proc,
                               remote_port_name[bi->remotetype],
                               bi->remote_port, bi->vme_addr, bi->endline);
                    }
                  else
                    {
                      sprintf (line,
                               "B %10s \tGLOBMEM \t%10s \t%d \t%d \t0 \t%d \t%d \t%s=%d %s",
                               bi->name, bi->host, bi->size, bi->neut,
                               bi->buffer_number, bi->max_proc,
                               remote_port_name[bi->remotetype],
                               bi->remote_port, bi->endline);
                    }
                  break;

                case CMS_BBDMEM_TYPE:
                  if (bi->bbd_size < 1)
                    {
                      bi->bbd_size = bi->orig_size;
                    }
                  sprintf (line,
                           "B %10s \tBBDMEM \t%10s \t%d \t%d \t0 \t%d \t%d  \t%s=%d bbd_size=%d force_type=%d %s",
                           bi->name, bi->host, bi->size, bi->neut,
                           bi->buffer_number, bi->max_proc,
                           remote_port_name[bi->remotetype], bi->remote_port,
                           bi->bbd_size, bi->force_type, bi->endline);
                  break;


                default:
                  sprintf (line,
                           "B %10s \t%7.7s \t%10s \t%d \t%d \t0 \t%d \t%d \t%s",
                           bi->name, buf_type_name[bi->buftype], bi->host,
                           bi->size, bi->neut, bi->buffer_number,
                           bi->max_proc, bi->endline);
                  break;
                }
              switch (bi->encoding_type)
                {
                case CMS_XDR_ENCODING:
                  strcat (line, " xdr");
                  break;

                case CMS_ASCII_ENCODING:
                  strcat (line, " ascii");
                  break;

                case CMS_DISPLAY_ASCII_ENCODING:
                  strcat (line, " disp");
                  break;

                case CMS_NO_ENCODING:
                default:
                  break;
                }
              if (bi->queue)
                {
                  strcat (line, " queue");
                }
              if (bi->use_autocnum)
                {
                  strcat (line, " autocnum");
                }
              if (bi->enable_diag)
                {
                  strcat (line, " diag");
                }
              if (bi->brpi > 0.0)
                {
                  sprintf (line + strlen (line), " brpi=%f", bi->brpi);
                }
            }
          fprintf (fp, "%s\n", line);
          memset (line, 0, 256);
        }
      bi = (BUFFER_INFO *) buffer_list.get_next ();
    }
  int first_process_line = 1;
  PROCESS_INFO *pi = (PROCESS_INFO *) process_list.get_head ();
  char last_pi_procname[80];
  int last_was_server = 0;
  CMS_PROCESSTYPE last_pi_proctype = CMS_REMOTE_TYPE;
  int last_was_master = 0;
  memset (last_pi_procname, 0, 80);
  char process_default_string[80];
  char *pds = process_default_string;
  memset (process_default_string, 0, 80);
  int process_default_string_needed = 0;

  while (pi != NULL)
    {
      while (comment != NULL && comment_num < pi->comment_num)
        {
          fprintf (fp, "%s\n", comment);
          comment = (char *) comments.get_next ();
          comment_num++;
        }
      if (first_process_line)
        {
          fprintf (fp, "\n# Processes: \n");
          if (!inverse_mode)
            {
              fprintf (fp,
                       "# %10s \t%10s \t%10s \t%10s \t%10s \tserver \ttimeout \tmaster \tc_num  \t . . .\n",
                       "Name", "Buffer", "type", "host", "ops");
            }
        }
      first_process_line = 0;
      if (inverse_mode)
        {
          strcpy (process_default_string, "process_default ");
          if (strcmp (pi->name, last_pi_procname))
            {
              pds = process_default_string + strlen (process_default_string);
              process_default_string_needed = 1;
              fprintf (fp, "\n");
              sprintf (pds, "name=%s ", pi->name);
              strcpy (last_pi_procname, pi->name);
            }
          if (last_was_server != pi->isserver)
            {
              pds = process_default_string + strlen (process_default_string);
              process_default_string_needed = 1;
              sprintf (pds, "server=%d ", pi->isserver);
              last_was_server = pi->isserver;
            }
          if (last_was_server != pi->master)
            {
              pds = process_default_string + strlen (process_default_string);
              process_default_string_needed = 1;
              sprintf (pds, "master=%d ", pi->master);
              last_was_master = pi->master;
            }
          if (last_pi_proctype != pi->proctype)
            {
              pds = process_default_string + strlen (process_default_string);
              process_default_string_needed = 1;
              sprintf (pds, "proctype=%s ", proc_type_name[pi->proctype]);
              last_pi_proctype = pi->proctype;
            }
          if (process_default_string_needed)
            {
              process_default_string_needed = 0;
              fprintf (fp, "%s\n", process_default_string);
              memset (process_default_string, 0, 80);
            }
          fprintf (fp, "p bufname=%s\n", pi->bufname);
        }
      else
        {
          if (!pi->oldstyle && pi->subscription_interval > 0.0)
            {
              if (pi->timeout > 0.0)
                {
                  fprintf (fp,
                           "P %10s \t%10s \t%10s \t%10s \t%10s \t%d \t%f \t%d \t%d sub=%f %10s\n",
                           pi->name, pi->bufname,
                           proc_type_name[pi->proctype], pi->host,
                           ops_string[pi->ops], pi->isserver, pi->timeout,
                           pi->master, pi->c_num, pi->subscription_interval,
                           pi->endline);
                }
              else
                {
                  fprintf (fp,
                           "P %10s \t%10s \t%10s \t%10s \t%10s \t%d \tINF \t%d \t%d sub=%f %10s\n",
                           pi->name, pi->bufname,
                           proc_type_name[pi->proctype], pi->host,
                           ops_string[pi->ops], pi->isserver, pi->master,
                           pi->c_num, pi->subscription_interval, pi->endline);
                }
            }
          else
            {
              int no_cnum = 0;
              if (pi->buf_info != 0)
                {
                  if (pi->buf_info->use_autocnum)
                    {
                      no_cnum = 1;
                    }
                }
              if (!strcmp (pi->name, "default"))
                {
                  no_cnum = 1;
                }
              if (!no_cnum)
                {
                  if (pi->timeout > 0.0)
                    {
                      fprintf (fp,
                               "P %10s \t%10s \t%10s \t%10s \t%10s \t%d \t%f \t%d \t%d %10s\n",
                               pi->name, pi->bufname,
                               proc_type_name[pi->proctype], pi->host,
                               ops_string[pi->ops], pi->isserver, pi->timeout,
                               pi->master, pi->c_num, pi->endline);
                    }
                  else
                    {
                      fprintf (fp,
                               "P %10s \t%10s \t%10s \t%10s \t%10s \t%d \tINF     \t%d \t%d %10s\n",
                               pi->name, pi->bufname,
                               proc_type_name[pi->proctype], pi->host,
                               ops_string[pi->ops], pi->isserver, pi->master,
                               pi->c_num, pi->endline);
                    }
                }
              else
                {
                  if (pi->timeout > 0.0)
                    {
                      fprintf (fp,
                               "P %10s \t%10s \t%10s \t%10s \t%10s \t%d \t%f \t%d \t% %10s\n",
                               pi->name, pi->bufname,
                               proc_type_name[pi->proctype], pi->host,
                               ops_string[pi->ops], pi->isserver, pi->timeout,
                               pi->master, pi->endline);
                    }
                  else
                    {
                      fprintf (fp,
                               "P %10s \t%10s \t%10s \t%10s \t%10s \t%d \tINF     \t%d \t %10s\n",
                               pi->name, pi->bufname,
                               proc_type_name[pi->proctype], pi->host,
                               ops_string[pi->ops], pi->isserver, pi->master,
                               pi->endline);
                    }
                }
            }
        }
      pi = (PROCESS_INFO *) process_list.get_next ();
    }
  while (comment != NULL)
    {
      fprintf (fp, "%s\n", comment);
      comment = (char *) comments.get_next ();
    }
  fprintf (fp, "\n");
  if (using_stdout)
    {
      fflush (fp);
    }
  else
    {
      fclose (fp);
    }
  return (0);
}

---