u_data.c

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

  }

/************************************************************************/
/*			cfg_jrnl_file					*/
/************************************************************************/

static ST_VOID cfg_jrnl_file (ST_VOID)
  {
ST_CHAR *name;

  if (name = cfg_get_string_ptr ())
    {
    pstJrnlCtrl->jrnlFile = chk_malloc (strlen (name) +1);
    strcpy (pstJrnlCtrl->jrnlFile, name);
    }
  else
    cfg_set_config_err ();
  }

/************************************************************************/
/*			cfg_jrnl_deletable				*/
/************************************************************************/

static ST_VOID cfg_jrnl_deletable (ST_VOID)
  {
  pstJrnlCtrl->bDeletable = SD_TRUE;
  }

/************************************************************************/
/*			cfg_jrnl_end					*/
/************************************************************************/

static ST_VOID cfg_jrnl_end (ST_VOID)
  {
JOURNAL *pstJournal;
NAMED_DOM_CTRL	*dom_ctrl;
DOMAIN_OBJS     *dom;

  if (pstJrnlCtrl->jrnlInProgress)
    {
    printf ("\n Adding Journal '%s'", pstJrnlCtrl->jrnlName);

    if (domain_specific == SD_TRUE)
      {
      printf (" to domain '%s'", named_domain);
      if (dom_ctrl = ms_find_named_dom (named_domain))
        {
        dom = &(dom_ctrl->objs);
        }
      else
        {
        dom = NULL;
        printf ("\n Bad DomainName '%s' Failed adding Journal '%s'",
                named_domain, pstJrnlCtrl->jrnlName);
        ms_perror (mms_op_err);
        wait_msg("");
        }
      }
    else
      {
      dom = &(m_vmd_select->vmd_wide);
      }

    pstJournal = ms_add_journal (dom, 
    			         pstJrnlCtrl->jrnlName,
				 pstJrnlCtrl->bDeletable);
    if (!pstJournal)
       wait_msg ("ADD Journal FAILURE");
    else
      pstJournal->usr = pstJrnlCtrl->jrnlFile;

    pstJrnlCtrl->jrnlInProgress = SD_FALSE;
    domain_specific = SD_FALSE;
    }

  /* Pop from stack the jrnl_name_kwtbl so that types section can be*/
  /* processed                                                          */
  cfg_tbl_pop (1);
  cfg_tbl_push (domains_base_kwtbl);
  }

/************************************************************************/
/*                         cfg_types_begin                              */
/************************************************************************/
/* Initial state for parsing Named Types cfg file                       */

static ST_VOID cfg_types_begin (ST_VOID)
  {
  /* Configuration file successfully opened, log msg */

  cfg_tbl_push (type_name_kwtbl);
  }

/************************************************************************/
/*                         cfg_type_name                                */
/************************************************************************/
/* Get Named Type name and save it in named_type_name var            */

static ST_VOID cfg_type_name (ST_VOID)
  {
ST_CHAR *type_name_ptr;

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

  if (type_name_ptr = cfg_get_string_ptr ())
    {
    strncpy (named_type_name, type_name_ptr, MAX_IDENT_LEN);
    cfg_tbl_push (type_def_kwtbl);
    }
  else
    cfg_set_config_err ();

  }

/************************************************************************/
/*                          cfg_type_def                                */
/************************************************************************/
/* Add Named Type definition                                            */

#define MAX_ASN1_TYPE_LEN 5000

static ST_VOID cfg_type_def (ST_VOID)
  {
ST_CHAR  *type_def;
ST_INT len;
ST_UCHAR *asn1ptr;
ST_UCHAR  *asn1_buf;
NAMED_TYPE *tnew = NULL;

  /* Get the type definition from file */
  if (type_def = cfg_get_string_ptr ())
    {
    /* We generate the ASN.1 encoding in a temporary var 	           */

    asn1_buf = chk_calloc (1, MAX_ASN1_TYPE_LEN);
    len = MAX_ASN1_TYPE_LEN;

    /* If the TDL is good then we allocate a chunk of memeory and put    */
    /* the ASN.1 encoding in.						   */

    if (asn1ptr = ms_mk_asn1_type (&len, asn1_buf, type_def))
      {
      if (ms_find_named_type (&m_vmd_select->vmd_wide, named_type_name) != NULL)
        {
        ms_del_named_type (&m_vmd_select->vmd_wide, named_type_name);
        }

      tnew = ms_add_named_type (&m_vmd_select->vmd_wide, named_type_name,
                           (ST_UCHAR *)asn1ptr, len);
      if (tnew)
        {
        printf ("\n Added custom type '%s', size %d",
                                   named_type_name, tnew->blocked_len);
        }
      else
        {
        printf ("\n Failed adding custom type '%s'",named_type_name);
        ms_perror (mms_op_err);
	wait_msg ("");
	}
      }
    else
      {
      printf ("\n TDL error for custom type '%s'",named_type_name);
      wait_msg ("");
      }

    chk_free (asn1_buf);
    }

  /* Pop from stack the type_def_kwtbl so that next type can be processed */
  cfg_tbl_pop (1);
  }

/************************************************************************/
/*                            cfg_types_end                             */
/************************************************************************/

static ST_VOID cfg_types_end (ST_VOID)
  {
  /* Pop from stack the type_name_kwtbl so that variables section can be*/
  /* processed                                                          */
  /* Push var_begin_kwtbl to read vars */
  cfg_tbl_pop (1);
  cfg_tbl_push (var_begin_kwtbl);
  }

/************************************************************************/
/*                         cfg_vars_begin                            */
/************************************************************************/
/* Parse the Named vars from configuration file                      */

static ST_VOID cfg_vars_begin (ST_VOID)
  {
  /* In Named vars section, log msg */

  init_var = SD_FALSE;
  cfg_tbl_push (var_name_kwtbl); 
  }


/************************************************************************/
/*                         cfg_var_name_init                            */
/************************************************************************/
/* User wants to initialize this one after it is added			*/

static ST_VOID cfg_var_name_init (ST_VOID)
  {
  init_var = SD_TRUE;
  cfg_var_name ();
  }

/************************************************************************/
/*                         cfg_var_name                              */
/************************************************************************/
/* Save the Named var name in named_var_name and push on stack    */
/* next keyword table                                                   */

static ST_VOID cfg_var_name (ST_VOID)
  {
  ST_CHAR    *var_name_ptr = NULL;

  /* Set the var name to empty str */
  memset (named_var_name, 0, VAR_NAME_BUF_LEN+1);

  if (var_name_ptr = cfg_get_string_ptr ())
    {
    strncpy (named_var_name, var_name_ptr, VAR_NAME_BUF_LEN);
    cfg_tbl_push (var_type_name_kwtbl);
    }
  }

/************************************************************************/
/*                    cfg_var_type_name                              	*/
/************************************************************************/
/* Save the Named var's type name in named_type_name and push on     	*/
/* stack next keyword table                                             */

static ST_VOID cfg_var_type_name (ST_VOID)
  {
ST_CHAR *type_name_ptr;
VAR_ACC_ADDR adr;
DOMAIN_OBJS  *dom_objs;
NAMED_DOM_CTRL *named_dom;
INITDOWN_REQ_INFO *dom_info;
OBJECT_NAME  type;
ST_CHAR *var_buffer;
ST_INT var_buffer_size;
NAMED_TYPE *tptr;
ST_CHAR *p;
ST_CHAR *vname;
ST_CHAR *dname;
ST_CHAR	address_string[40];
NAMED_VAR *vptr;

  type_name_ptr = cfg_get_string_ptr ();
  tptr = ms_find_named_type (&m_vmd_select->vmd_wide, type_name_ptr);
  if (!tptr)
    {
    printf ("\n Could not find type %s",type_name_ptr);
    init_var = SD_FALSE;
    cfg_tbl_pop (1);
    return;
    }

  /* Allocate a buffer for this variable				*/
  /* Add a few bytes of pad, just to be generous			*/
  var_buffer_size = tptr->blocked_len + 10;
  var_buffer = chk_calloc (1,var_buffer_size);

  type.object_tag = VMD_SPEC; 		/* select VMD scope type	*/
  strcpy (type.obj_name.vmd_spec, type_name_ptr);

  adr.addr_tag = SYM_ADDR;
  sprintf (address_string, "0x%p", var_buffer);
  adr.addr.sym_addr = address_string;	/* MMS-EASE will allocate required space */

  p = strstr (named_var_name, ".");
  if (!p)
    {
    dom_objs = &m_vmd_select->vmd_wide;  
    vname = named_var_name;
    dname = NULL;
    }
  else	/* name form is "domname.varname" */
    {
    *p = 0;
    dname = named_var_name;
    named_dom = ms_find_named_dom (dname);
    if (named_dom)
      dom_objs = &named_dom->objs;  
    else
      {		/* Try to add the domain now */
      dom_info = (INITDOWN_REQ_INFO *) dest_buffer;
      strcpy (dom_info->dname, dname);
      dom_info->sharable = SD_TRUE;
      dom_info->num_of_capab = 0;
      named_dom = ms_add_named_domain (dom_info, 0x7F);
      
      if (named_dom)
        {
        dom_objs = &named_dom->objs;  
        printf ("\n Added custom domain '%s'", dname);
        }
      else
        {
        printf ("\n Could not find/create domain '%s', using VMD", dname);
	wait_msg ("");
        dom_objs = &m_vmd_select->vmd_wide;  
        dname = NULL;
        }
      }
    vname = p+1;
    }

  if (!(vptr = ms_add_named_var (dom_objs,vname,&type,&adr,0)))
    {
    printf ("\n Error adding variable '%s' of type '%s' ",
    				       		vname,
                                                type_name_ptr);

    if (dname)
      printf (" to Domain '%s'", dname);
    ms_perror (mms_op_err);
    wait_msg ("");
    }
  else
    {
    ms_add_unnamed_var((ST_UCHAR *)var_buffer,tptr,(ST_UCHAR *)&vptr->varname);
    printf ("\n Added custom variable '%s'", vname);
    if (dname)
      printf (" to Domain '%s'", dname);

    if (init_var)
      {
      if (read_var_data (var_buffer, vname, 
			  tptr->rt_head, tptr->rt_num))
        {
        get_arb_write_data (var_buffer, tptr->rt_head, tptr->rt_num);
        }
      }
    }
  init_var = SD_FALSE;
  cfg_tbl_pop (1);
  }

/************************************************************************/
/*                          cfg_vars_end                             */
/************************************************************************/

static ST_VOID cfg_vars_end (ST_VOID)
  {
  cfg_tbl_pop (2);
  cfg_set_endfile_ok ();
  cfg_tbl_push (var_list_begin_kwtbl);
  }

/************************************************************************/
/*                         cfg_var_lists_begin                          */
/************************************************************************/
/* Parse the Named Var Lists from configuration file                    */

static ST_VOID cfg_var_lists_begin (ST_VOID)
  {
  /* In Named Var Lists section, log msg */

  init_var = SD_FALSE;
  cfg_tbl_push (named_var_list_kwtbl); 
  }

/************************************************************************/
/*                         cfg_var_list_name                            */
/************************************************************************/
/* Save the Named var list name in named_var_list_name and push on      */
/* stack next keyword table                                             */

static ST_VOID cfg_var_list_name (ST_VOID)
  {
  ST_CHAR    *var_list_name_ptr = NULL;

  /* Set the var name to empty str */
  memset (named_var_list_name, 0, VAR_NAME_BUF_LEN+1);
  memset (named_domain, 0, MAX_IDENT_LEN+1);
  domain_specific = SD_FALSE;

  /* Set the location for the first Named Variable			*/
  vl_ptr = (VARIABLE_LIST *)dest_buffer;
  num_of_variables = 0;

  if (var_list_name_ptr = cfg_get_string_ptr ())
    {
    strncpy (named_var_list_name, var_list_name_ptr, VAR_NAME_BUF_LEN);
    cfg_tbl_push (var_list_kwtbl); 
    }
  }

/************************************************************************/
/*                         cfg_vlist_nvar                               */
/************************************************************************/
/* Save the Named var name in a VARIALBE_LIST strucutre			*/

static ST_VOID cfg_vlist_nvar (ST_VOID)
  {
  ST_CHAR    *var_name_ptr = NULL;

  /* Set the VARIALBE_LIST to NAMED and VMD-Specific			*/
  vl_ptr->var_spec.var_spec_tag = VA_SPEC_NAMED;
  vl_ptr->alt_access_pres = SD_FALSE;

  if (var_name_ptr = cfg_get_string_ptr ())
    {
    if (domain_specific == SD_TRUE)
      {
      vl_ptr->var_spec.vs.name.object_tag = DOM_SPEC; 
      strncpy (vl_ptr->var_spec.vs.name.obj_name.item_id, var_name_ptr, 
               MAX_IDENT_LEN);
      strncpy (vl_ptr->var_spec.vs.name.domain_id, named_domain, 
               MAX_IDENT_LEN);
      }
    else