u_data.c

ICCP Toolkit 是在 Tru64下开发Tase.2通信协议的开发包

      {
      vl_ptr->var_spec.vs.name.object_tag = VMD_SPEC; 
      strncpy (vl_ptr->var_spec.vs.name.obj_name.vmd_spec, var_name_ptr, 
               MAX_IDENT_LEN);
      }
    vl_ptr++;
    num_of_variables++;
    }
  }

/************************************************************************/
/*                         cfg_vlist_ndom                               */
/************************************************************************/
/* Save the domain name 						*/
/* stack next keyword table                                             */

static ST_VOID cfg_vlist_ndom (ST_VOID)
  {
  ST_CHAR    *dom_name_ptr = NULL;

  /* Set the var name to empty str */

  memset (named_domain, 0, MAX_IDENT_LEN+1);
  if (dom_name_ptr = cfg_get_string_ptr ())
    {
    strncpy (named_domain, dom_name_ptr, MAX_IDENT_LEN);
    domain_specific = SD_TRUE;
    }
  }

/************************************************************************/
/*                          cfg_vlist_end                               */
/************************************************************************/

static ST_VOID cfg_vlist_end (ST_VOID)
  {
NAMED_DOM_CTRL	*dom_ctrl;
DOMAIN_OBJS	*dom;

  cfg_tbl_pop (1);

/* Now it's time to add this Named Variable List			*/


  if (domain_specific == SD_TRUE)
    {
    if (dom_ctrl = ms_find_named_dom (named_domain))
      {
      dom = &(dom_ctrl->objs);
      }
    else
      {
      printf ("\n Bad DomainName '%s' Failed adding custom named variable list '%s'",
	      named_domain, named_var_list_name);
      ms_perror (mms_op_err);
      wait_msg("");
      }
    }
  else
    {
    dom = &(m_vmd_select->vmd_wide);
    }

  if (ms_add_nvlist (dom, named_var_list_name,
                      num_of_variables, (VARIABLE_LIST *)dest_buffer))
    {
    printf ("\n Added custom named variable list '%s'", 
            named_var_list_name);
    if (domain_specific == SD_TRUE) printf (" to domain '%s'", named_domain);
    }
  else
    {
    printf ("\n Failed adding custom named variable list '%s'",
            named_var_list_name);
    ms_perror (mms_op_err);
    wait_msg("");
    }
  }

/************************************************************************/
/*                          cfg_varlists_end                            */
/************************************************************************/

static ST_VOID cfg_varlists_end (ST_VOID)
  {
  cfg_tbl_pop (1);
  cfg_set_endfile_ok ();
  cfg_tbl_push (var_blocks_begin_kwtbl);
  }

/************************************************************************/
/*			   cfg_var_blocks_begin				*/
/************************************************************************/

static ST_VOID cfg_var_blocks_begin (ST_VOID)
  {
  cfg_tbl_pop (1);
  cfg_tbl_push (var_block_begin_kwtbl);
  }

/************************************************************************/
/*			  cfg_var_block_begin				*/
/************************************************************************/

static ST_VOID cfg_var_block_begin (ST_VOID)
  {
  cfg_tbl_push (var_block_kwtbl);
  }

/************************************************************************/
/*			    cfg_var_blocks_end				*/
/************************************************************************/

static ST_VOID cfg_var_blocks_end (ST_VOID)
  {
  cfg_tbl_pop (1);
  cfg_set_endfile_ok ();
  }

static ST_CHAR block_type_name[MAX_IDENT_LEN+1];
static ST_INT  block_num_vars;
static ST_CHAR block_base_var_name[MAX_IDENT_LEN+1];
static ST_INT  block_update_type;
static ST_INT  block_update_interval;

/************************************************************************/
/*			    cfg_block_type_name				*/
/************************************************************************/

static ST_VOID cfg_block_type_name (ST_VOID)
  {
ST_CHAR *type_name_ptr;

  /* Set the type name var to empty str */
  memset (block_type_name, 0, MAX_IDENT_LEN+1);

  if (type_name_ptr = cfg_get_string_ptr ())
    {
    strncpy (block_type_name, type_name_ptr, MAX_IDENT_LEN);
    }
  else
    cfg_set_config_err ();
  }

/************************************************************************/
/*			    cfg_block_num_vars				*/
/************************************************************************/

static ST_VOID cfg_block_num_vars (ST_VOID)
  {
ST_UINT val;

  if (cfg_get_uint (&val) == SD_SUCCESS)
    {
    block_num_vars = (ST_INT)val;
    }
  else
    cfg_set_config_err ();
  }

/************************************************************************/
/*			  cfg_block_base_var_name			*/
/************************************************************************/

static ST_VOID cfg_block_base_var_name (ST_VOID)
  {
ST_CHAR *base_name_ptr;

  /* Set the type name var to empty str */
  memset (block_base_var_name, 0, MAX_IDENT_LEN+1);

  if (base_name_ptr = cfg_get_string_ptr ())
    {
    strncpy (block_base_var_name, base_name_ptr, MAX_IDENT_LEN);
    }
  else
    cfg_set_config_err ();
  }

/************************************************************************/
/*			 cfg_block_update_on_read			*/
/************************************************************************/

static ST_VOID cfg_block_update_on_read (ST_VOID)
  {
ST_UINT val;

  block_update_type = UPDATE_ON_READ;

  if (cfg_get_uint (&val) == SD_SUCCESS)
    {
    block_update_interval = (ST_INT)val;
    }
  else
    cfg_set_config_err ();
  }		      

/************************************************************************/
/*			  cfg_block_update_on_time			*/
/************************************************************************/

static ST_VOID cfg_block_update_on_time	(ST_VOID)
  {
ST_UINT val;

  block_update_type = UPDATE_ON_TIME;
  if (cfg_get_uint (&val) == SD_SUCCESS)
    {
    block_update_interval = (ST_INT)val;
    }
  else
    cfg_set_config_err ();
  }

/************************************************************************/
/*			    cfg_var_block_end				*/
/************************************************************************/

static ST_VOID cfg_var_block_end (ST_VOID)
  {
  cfg_tbl_pop (1);
  add_var_block (block_type_name,
                 block_num_vars,
		 block_base_var_name,
		 block_update_type,
		 block_update_interval);
  }

/************************************************************************/
/*			read_var_data					*/
/************************************************************************/

static FILE *dataInitFp;

static ST_RET initInt8  (ST_INT8   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  fscanf (dataInitFp," %d ", &i);
  *data_dest = (ST_INT8) i;
  return (SD_SUCCESS);
  }

static ST_RET initInt16 (ST_INT16  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  fscanf (dataInitFp," %d ", &i);
  *data_dest = (ST_INT16) i;
  return (SD_SUCCESS);
  }

static ST_RET initInt32 (ST_INT32   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG l;

  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_INT32) l;
  return (SD_SUCCESS);
  }

static ST_RET initInt64 (ST_INT64   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG l;

  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_INT64) l;
  return (SD_SUCCESS);
  }
static ST_RET initUint8  (ST_UINT8   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  fscanf (dataInitFp," %d ", &i);
  *data_dest = (ST_UINT8) i;
  return (SD_SUCCESS);
  }

static ST_RET initUint16 (ST_UINT16  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  fscanf (dataInitFp," %d ", &i);
  *data_dest = (ST_UINT16) i;
  return (SD_SUCCESS);
  }

static ST_RET initUint32 (ST_UINT32   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG l;

  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_UINT32) l;
  return (SD_SUCCESS);
  }

static ST_RET initUint64 (ST_UINT64   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG l;

  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_UINT64) l;
  return (SD_SUCCESS);
  }


static ST_RET initFlt   (ST_FLOAT  *data_dest, RT_AA_CTRL *rtaa)
  {
  fscanf (dataInitFp," %f ", data_dest);
  return (SD_SUCCESS);
  }

static ST_RET initDbl   (ST_DOUBLE *data_dest, RT_AA_CTRL *rtaa)
  {
  fscanf (dataInitFp," %lf ", data_dest);
  return (SD_SUCCESS);
  }

static ST_RET initOct   (ST_UCHAR  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Sorry, no octet string initialization allowed");
  return (SD_SUCCESS);
  }

static ST_RET initBool  (ST_BOOLEAN  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  fscanf (dataInitFp," %d ", &i);
  *data_dest = (ST_BOOLEAN) i;
  return (SD_SUCCESS);
  }

static ST_RET initBs    (ST_UCHAR  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Sorry, no bitstring initialization allowed");
  return (SD_SUCCESS);
  }

static ST_RET initVis   (ST_CHAR  *data_dest, RT_AA_CTRL *rtaa)
  {
  fscanf (dataInitFp," %s ", data_dest);
  return (SD_SUCCESS);
  }

static ST_RET initBt4   (ST_INT32 *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG l;

  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_INT32) l;
  return (SD_SUCCESS);
  }

static ST_RET initBt6   (ST_INT32 *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG l;

  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_INT32) l;
  ++data_dest;
  fscanf (dataInitFp," %ld ", &l);
  *data_dest = (ST_INT32) l;
  return (SD_SUCCESS);
  }

static ST_RET initGt   (time_t *data_dest, RT_AA_CTRL *rtaa)
  {
  time (data_dest);
  return (SD_SUCCESS);
  }

static ST_RET initUtc   (MMS_UTC_TIME *data_dest, RT_AA_CTRL *rtaa)
  {
  data_dest->secs = time(NULL);
  data_dest->fraction = 0;
  data_dest->qflags = 0x1F;
  return (SD_SUCCESS);
  }


static M_ARB_DATA_CTRL arb_init_ctrl =
  {
  NULL, 	/* arrStart 	*/
  NULL, 	/* arrEnd    	*/
  NULL, 	/* strStart  	*/
  NULL, 	/* strEnd    	*/
  initInt8,  	/* int8      	*/
  initInt16,	/* int16     	*/
  initInt32, 	/* int32     	*/
  initInt64, 	/* int64     	*/
  initUint8, 	/* uint8     	*/
  initUint16,	/* uint16    	*/
  initUint32,	/* uint32    	*/
  initUint64,	/* uint64    	*/
  initFlt,   	/* flt       	*/
  initDbl,   	/* dbl       	*/
  initOct, 	/* oct       	*/
  initBool, 	/* bool      	*/
  initInt8, 	/* bcd1      	*/
  initInt16, 	/* bcd2      	*/
  initInt32, 	/* bcd4      	*/
  initBs, 	/* bs	       	*/
  initVis, 	/* vis       	*/
  initBt4, 	/* Bin Time    	*/
  initBt6, 	/* Bin Time    	*/
  initGt, 	/* Gen Time    	*/
  initUtc 	/* UTC Time    	*/
  };

#define LINE_BUF_SIZE 80

static ST_RET read_var_data (ST_CHAR *dest, ST_CHAR *varname, 
			  RUNTIME_TYPE *rt_head, ST_INT rt_num) 
  {
ST_CHAR fname[200];
ST_BOOLEAN alt_acc_pres = SD_FALSE;
ST_BOOLEAN alt_acc_packed = SD_FALSE; 
ALT_ACCESS *alt_acc_ptr