/************************************************************************/
/* SISCO SOFTWARE MODULE HEADER *****************************************/
/************************************************************************/
/*   (c) Copyright Systems Integration Specialists Company, Inc.,	*/
/*      	  1986 - 2003, All Rights Reserved.		        */
/*									*/
/* MODULE NAME : mms_vvar.h						*/
/* PRODUCT(S)  : MMSEASE						*/
/*									*/
/* MODULE DESCRIPTION : 						*/
/*	This module contains data and function definitions associated	*/
/*	with the MMS virtual machine variable access operations.	*/
/*									*/
/* MODIFICATION LOG :							*/
/*  Date     Who   Rev			Comments			*/
/* --------  ---  ------   -------------------------------------------	*/
/* 07/29/05  MDE     51	   Select USE_RT_TYPE_3 for USPS_IOS		*/
/* 05/09/05  JRB     50    Default to USE_RT_TYPE_2 (was USE_RT_TYPE_3).*/
/* 03/10/05  JRB     49    Add ms_rt_el_tag_text proto.			*/
/* 02/22/05  JRB     48    ms_is_rt_prim: add SD_CONST to arg.		*/
/* 01/27/05  JRB     47    Add m_lite_data_algn_tbl extern.		*/
/* 07/22/04  JRB     46    Add rt_index_q, rt_index_t, data_offset to	*/
/*			   RUNTIME_TYPE if !MMS_LITE.			*/
/* 07/12/04  JRB     45    Chg RT_UTF8_STRING tag from 18 to 16 to	*/
/*			   match latest 61850-8-1.			*/ 
/* 01/22/04  JRB     44    Add ms_local_to_text.			*/
/* 10/03/03  JRB     43    Chg offset_to_last & offSet to ST_INT32 in	*/
/*			   RUNTIME_TYPE to handle BIG IEC-61850 types.	*/
/* 03/31/03  JRB     42    Add UTF8string support (see RT_UTF8_STRING).	*/
/*			   Add "utf8" to M_ARB_DATA_CTRL.		*/
/* 03/13/03  JRB     41    u_ml_get_rt_type: Chg from "func ptr" to func.*/
/* 01/02/03  JRB     40    Add arg to u_ml_get_rt_type.			*/
/*			   Add ASN1_TO_RT_DEC_INFO struct.		*/
/* 12/27/02  MDE     39	   Allow use of ms_asn1_to_runtime		*/
/* 12/17/02  JRB     38    Del SD_CONST from numMvlRtNames.		*/
/* 12/16/02  JRB     37    Chg ms_is_rt_prim from macro to function.	*/
/* 11/27/02  MDE     36    Added ms_is_rt_prim				*/
/* 11/11/02  JRB     35    Add RUNTIME_CTRL, chg ms_runtime_create &	*/
/*			   ms_runtime_destroy to use it.		*/
/*			   Del ms_asn1_to_runtime (use ms_runtime_create)*/
/*			   Add ms_tdl_to_runtime proto.			*/
/* 03/01/02  JRB     34    Add SD_CONST to (RUNTIME_TYPE *) in RT_AA_CTRL.*/
/* 02/06/02  JRB     33    Deleted unused MMS_ALTA_DATA			*/
/* 12/20/01  JRB     32    Convert to use ASN1R.			*/
/*			   Add ASN1_ENC_CTXT arg to ms_*_to_asn1*.	*/
/*			   Add new function ms_local_to_asn1_easy.	*/
/* 11/13/01  EJV     31    Added support for new MMS type UtcTime:	*/
/*			   Added RT_UTC_TIME, chg RT_STR_END, RT_ARR_END*/
/*			   M_ARB_DATA_CTRL: added utc fun proto.	*/
/* 06/20/01  EJV     30    Added () around rt in ms_comp_name_xxx macros*/
/*			   to handle rt+1, rt-1 arguments.		*/
/* 04/11/01  MDE     29    Added ms_comp_name_pres macros		*/
/* 01/21/01  EJV     28    M_ARB_DATA_CTRL: changed bool to booln,	*/
/*			   to avoid conflict w/ bool type in C++ files.	*/
/* 11/02/00  JRB     27    Del #if MVL_UCA. Use #if MMS_LITE instead.	*/
/* 10/25/00  JRB     26    Del MVL_UCA define (define in makefile).	*/
/*			   Move ST_RTREF typedef so always defined.	*/
/* 08/29/00  JRB     25    Chg ms_comp_name_find from funct to macro.	*/
/* 07/28/00  JRB     24    Simplify RT_TYPE ifdefs.			*/
/*			   Fix SD_CONST in some prototypes.		*/
/*			   Del m_type_nam* externs, only used in 1 file.*/
/* 07/13/00  JRB     23    Add "#ifdef USE_RT_TYPE_2".			*/
/*			   Add ms_runtime_create, ms_runtime_destroy,	*/
/*			     ms_comp_name_find.				*/
/* 06/22/00  MDE     22    Added numMvlRtNames declaration		*/
/* 06/16/00  JRB     21    Add #if INT64_SUPP...			*/
/* 04/20/00  JRB     20    Del SD_CONST from (RUNTIME_TYPE **) args.	*/
/* 09/13/99  MDE     19    Added SD_CONST modifiers			*/
/* 09/10/98  MDE     18    Added 'mvlRtNames' declaration		*/
/* 08/11/98  MDE     17    Minor changes for Foundry			*/
/* 06/30/98  MDE     16    Changed ST_REF to ST_VOID *			*/
/* 04/07/98  MDE     15    Added struct/arr start/end alignment mode	*/
/* 03/23/98  MDE     14    Now let user supply AA derived type (RD/WR)	*/
/* 03/12/98  MDE     13    MMS-Lite related runtime type changes	*/
/* 03/11/98  MDE     12    Removed NEST_RT_TYPES			*/
/* 02/10/98  MDE     11    Changed runtime type				*/
/* 12/29/97  MDE     10    Added 'typeCtrl' to RUNTIME_TYPE for use	*/
/* 			   with 'mktypes.exe' only.			*/
/* 09/11/97  MDE     09    MMS ARB user funs now return ST_RET		*/
/* 09/04/97  NAV     08    Split ARB Btime functions & add 		*/
/*			     have them return a ST_BOOLEAN		*/
/* 08/15/97  MDE     07    BTOD handling comments			*/
/* 08/14/97  RKR     06    Format changes				*/
/* 07/16/97  RKR     05    Added more 64 bit integer support		*/
/* 06/23/97  RKR     04    Added arbitrary data handling		*/
/* 06/20/97  MDE     03    Added 64 bit integer support			*/
/* 06/09/97  MDE     02    Changed Runtime Type and it's use		*/
/* 06/05/97  RKR     01    Removed AA_OUTER_NEST rearranged AA constants*/
/* 04/02/97  DTL   7.00    MMSEASE 7.0 release. See MODL70.DOC for	*/
/*			   history.					*/
/************************************************************************/

#ifndef MMS_VVAR_INCLUDED
#define MMS_VVAR_INCLUDED

#ifndef MMS_LITE
#include "mms_mv.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif


/************************************************************************/
/************************************************************************/
/* BINARY TIME OF DAY NOTES						*/
/* There are two forms of TimeOfDay, 4 byte and 6 byte.			*/
/* The 6 byte form contains the number of milliseconds since midnight	*/
/* and the number of days since Jan 1, 1984. The 4 byte form contains	*/
/* only the millisecond number. 					*/
/*									*/
/* In memory, the Btime6 data looks like a pair of 32 bit integers:	*/
/*   ST_INT32 ms;	      Number of milliseconds since midnight	*/
/*   ST_INT32 day;	      Number of days since Jan 1, 1984		*/
/*									*/
/* and the Btime4 data looks like a single 32 bit integer:		*/
/*   ST_INT32 ms;	      Number of milliseconds since midnight	*/
/*									*/
/* Data alignment for either form is that of a ST_INT32.		*/
/* Note that MMS-EASE simply encodes/decodes the values to/from the 	*/
/* MMS PDU and does not perform any local time localization.		*/
/************************************************************************/

/************************************************************************/
/************************************************************************/
/* MMS-LITE 								*/
/************************************************************************/

/* Default to USE_RT_TYPE_2 for MMS Lite (allows dynamic type creation).*/
/* NOTE: define USE_RT_TYPE_3 only if you need to store RUNTIME_TYPES	*/
/*   in ROM, and you DO NOT need dynamic type creation.			*/

#if defined(MMS_LITE) && (!defined(USE_RT_TYPE_3))
#define USE_RT_TYPE_2
#endif

/* The IOS Toolkit requires RT_TYPE_3 */
#ifdef USPS_IOS
#undef USE_RT_TYPE_2
#define USE_RT_TYPE_3
#endif

#if defined(FOUNDRY)	/* Overwride defines when compiling Foundry	*/
#undef USE_RT_TYPE_2
#undef USE_RT_TYPE_3
#endif

/* RUNTIME TYPE INTEGER FORM						*/
/* In MMS-LITE the size of the RUNTIME_TYPE must be minimized, so we	*/
/* will use 16 bit integers for the compoments. This puts a 32K limit	*/
/* on the size of a variable. 						*/

#if !defined(MMS_LITE)
#define ST_RTINT  ST_INT
#else
#define ST_RTINT  ST_INT16
#endif

/************************************************************************/
/* MMS-LITE UCA SPECIFIC SECTION					*/
/************************************************************************/
/* MMS-LITE uses an extended RUNTIME_TYPE for use with the MVL UCA 	*/
/* object handling extensions.						*/
/* To use the UCA extensions, MVL_UCA must be defined.			*/
/* NOTE: MVL_UCA is NOT defined by default.				*/

/* This typedef is for the application use only and can be changed as 	*/
/* required. Normally it is used to allow the applcation to consolidate	*/
/* MVL_UCA read and write indication handler functions.			*/
typedef ST_VOID *  ST_RTREF;

/* These elements are designed to be used to assist in implementing the */
/* UCA device models in MMS-EASE Lite. Note that 'MVL_UCA' must be 	*/
/* defined when creating the MMS-EASE libraries if these features are	*/
/* to be used.								*/

/* You may comment out the defines for those components that will not	*/
/* bs used in the target application to reduce the size of the 		*/
/* RUNTIME_TYPE table.							*/
#define MVLU_USE_REF

typedef struct mvluTypeStruct 
  {
  ST_RTINT sortedNum;	/* For use by MVLU GNL code 			*/
  ST_INT32 offSet;	/* Offset from start of mother structure 	*/
  ST_RTINT rdIndFunIndex;	
  ST_RTINT wrIndFunIndex;	

/* These elements can be used by the application as needed, and are	*/
/* copied into the derived variable association. MVLU does not use them	*/
/* directly.								*/
#if defined(MVLU_USE_REF)
  ST_RTREF ref;		/* set to 'XXX$YYY_REF' by foundry 		*/
#endif
  } MVLU_TYPE_INFO;

/************************************************************************/
/* RUNTIME TYPE DEFINITION STRUCTURE					*/
/************************************************************************/
/* The following defines specify the various data parameters		*/
/************************************************************************/

#define RT_ARR_START	        1
#define RT_STR_START	        2
#define	RT_BOOL		        3
#define	RT_BIT_STRING	        4
#define	RT_INTEGER		5
#define	RT_UNSIGNED	        6
#define	RT_FLOATING_POINT	7
#define	RT_OCTET_STRING	        9
#define	RT_VISIBLE_STRING	10
#define	RT_GENERAL_TIME	        11
#define	RT_BINARY_TIME	        12
#define	RT_BCD		        13
#define	RT_BOOLEANARRAY	        14
#define	RT_UTC_TIME	        17
#define	RT_UTF8_STRING		16	/* specified in IEC-61850-8-1	*/
/* ADD new tags here and bump up RT_MAX_PRIM_TAG accordingly.	*/
#define RT_MAX_PRIM_TAG		18	/* use when looking for max tag val*/
#define RT_STR_END 	        (RT_MAX_PRIM_TAG+1)
#define RT_ARR_END 	        (RT_MAX_PRIM_TAG+2)

struct runtime_type
  {
  ST_UCHAR el_tag; 	/* ID tag expected for this element, or special */
			/* values for end of array, end of struct	*/
			/* or nested runtime types			*/

  ST_RTINT   el_size;	/* number of bytes occupied by this element	*/
  ST_INT32   offset_to_last; /* offset in bytes from the start of the 	*/
                         /* data to the last element 		 	*/
  union
    {
    struct		 /* primitive element				*/
      {
      ST_RTINT el_len;	 /* precision, in bytes except bitstr, time	*/
      ST_RTINT pad;	 /* included to allow aggregate initialization	*/
      } p;
    struct		 /* structure (top or bottom)			*/
      {
      ST_RTINT num_rt_blks; /* # runtime blks to get to strt/end elmnt	*/
      ST_RTINT pad;	 /* included to allow aggregate initialization	*/
#if !defined(USE_RT_TYPE_2) && !defined(USE_RT_TYPE_3)
      ST_BOOLEAN packd;	 /* Indicates if packed or not.			*/
#endif
      } str;
    struct		 /* Array (top or bottom)			*/
      {
      ST_RTINT num_elmnts;  /* # array elements (index limit)		*/
      ST_RTINT num_rt_blks; /* # runtime blks to get to strt/end elmnt	*/
#if !defined(USE_RT_TYPE_2) && !defined(USE_RT_TYPE_3)
      ST_BOOLEAN packd;	 /* Indicates if packed or not.			*/
#endif
      } arr;
    } u;

#if defined(USE_RT_TYPE_2)
  ST_CHAR *comp_name_ptr;		/* ptr to comp name string	*/
#elif defined(USE_RT_TYPE_3)
  ST_RTINT name_index;	 		/* Index into mvlRtNames table	*/
#else					/* Default			*/
  ST_CHAR name[MAX_IDENT_LEN+1];
#endif

#if defined(MMS_LITE)
  MVLU_TYPE_INFO mvluTypeInfo;	    	/* MMS-LITE UCA handler use	*/
#endif
#if defined(FOUNDRY)
  ST_CHAR *refBuf;
  ST_CHAR *rdIndexBuf;
  ST_CHAR *wrIndexBuf;
#endif
#if !defined (MMS_LITE)
  ST_RTINT rt_index_q;		/* index into RUNTIME_TYPE array for 'q'*/
				/* attribute of IEC-61850 type		*/
  ST_RTINT rt_index_t;		/* index into RUNTIME_TYPE array for 't'*/
				/* attribute of IEC-61850 type		*/
  ST_INT32 data_offset;		/* offset in bytes from start of data	*/
				/* NOTE: should be same as offSet in	*/
				/*      mvluTypeInfo above for MMS_LITE	*/
#endif
  };
typedef struct runtime_type RUNTIME_TYPE;

/* Runtime type HEAD struct contains info about RUNTIME_TYPE array.	*/
typedef struct
  {
  RUNTIME_TYPE *rt_first;	/* ptr to first in array of structs	*/
  ST_INT rt_num;		/* num entries in RUNTIME_TYPE array	*/
  } RUNTIME_CTRL;

/************************************************************************/
/* ASN1_TO_RT_DEC_INFO - structure to store temporary decode info.	*/
/************************************************************************/
typedef struct
  {
#if defined(USE_RT_TYPE_2)
/* These are used for saving component names.				*/
  ST_CHAR *comp_name_buf;	/* Alloc'd buf to store ALL component names.*/
  ST_INT   comp_name_size;	/* Buffer size (in bytes)		*/
  ST_INT   comp_name_used;	/* Running count of bytes needed OR used.*/

  ST_CHAR *comp_name_ptr;	/* current position in buffer.		*/
#endif
  RUNTIME_TYPE  *rt_start;	/* ptr to runtime table start	*/
  ST_BOOLEAN calc_only;		/* flag to calculate num rt blocks	*/
  /* DEBUG: add rt_ptr, rt_count, rt_limit, etc. & delete global vars.*/
  } ASN1_TO_RT_DEC_INFO;

#if defined(MMS_LITE)
ST_RET u_ml_get_rt_type (ASN1_DEC_CTXT *aCtx, OBJECT_NAME *type_name, 
      			   RUNTIME_TYPE **rt_out, ST_INT *num_rt_out);

extern ST_INT maxMvlRtNames;
extern ST_INT numMvlRtNames;
extern ST_CHAR **mvlRtNames;
#endif

ST_BOOLEAN ms_is_rt_prim (SD_CONST RUNTIME_TYPE *rt);
ST_CHAR *ms_rt_el_tag_text (SD_CONST RUNTIME_TYPE *rt_type);

/************************************************************************/
/* ALTERNATE ACCESS DEFINITION STRUCTURE  				*/
/************************************************************************/

/* Possible values for sel_type                                         */
#define AA_COMP		        0
#define AA_INDEX 	        1
#define AA_INDEX_RANGE	        2
#define AA_ALL	                3
#define AA_COMP_NEST		4
#define AA_INDEX_NEST 	        5
#define AA_INDEX_RANGE_NEST	6
#define AA_ALL_NEST	        7
#define AA_END_NEST             8

#define MAX_NUM_AA_EL		100

struct alt_acc_el
  {
  ST_BOOLEAN comp_name_pres;
  ST_CHAR    comp_name[MAX_IDENT_LEN+1];/* named component for derived 	*/
					/* type				*/
  ST_INT sel_type;			/* type of access selection	*/
  union
    {
    ST_CHAR component[MAX_IDENT_LEN+1];	/* Used for AA_COMP		*/ 
    ST_UINT32 index;			/* Used for AA_INDEX		*/
    struct		  		/* Used for AA_INDEX_RANGE	*/
      {
      ST_UINT32 low_index;
      ST_UINT32 num_elmnts;
      } ir;
    } u;
  };
typedef struct alt_acc_el ALT_ACC_EL;

struct alt_access
  {
  ST_INT     num_aa;
  ALT_ACC_EL *aa;
  };
typedef struct alt_access ALT_ACCESS;


/* This data structure is used in table form to implement alternate	*/
/* access from the server perspective (NEWDATA <-> ASN1DATA)		*/
/* It allows re-ordering of elements as well as limited selection	*/

struct rt_aa_ctrl
  {
  SD_CONST RUNTIME_TYPE *rt;
  ST_UINT      offset_to_data;	/* offset to data element		*/
  ST_INT       el_size;		/* Size of the element in memory	*/
  };
typedef struct rt_aa_ctrl RT_AA_CTRL;

ST_RET ms_adl_to_aa (ST_CHAR *adl_str,ALT_ACCESS *alt_acc);

ST_RET ms_aa_to_adl (ALT_ACCESS *alt_acc, 
                     ST_CHAR *adl_str, 
		     ST_INT max_adl_len);

ST_RET ms_local_to_asn1_aa (ASN1_ENC_CTXT *aCtx, SD_CONST RUNTIME_TYPE *rt_head,
			    ST_INT rt_num,
                            ALT_ACCESS *alt_acc,
                            ST_CHAR *dptr);

ST_RET ms_asn1_to_local_aa (SD_CONST RUNTIME_TYPE *rt_head,
                            ST_INT rt_num,
                            ALT_ACCESS *alt_acc,
                            ST_UCHAR *asn1ptr,
                            ST_INT asn1len,
                            ST_CHAR *dptr);


ST_VOID ms_log_alt_access (ALT_ACCESS *alt_acc);


ST_RET ms_aa_to_asn1 (ASN1_ENC_CTXT *aCtx, ALT_ACCESS *alt_acc);
ST_RET ms_asn1_to_aa (ST_UCHAR *asn1ptr, ST_INT asn1len, 
                      ALT_ACCESS *alt_acc_out);


/************************************************************************/
#ifndef MMS_LITE
/************************************************************************/
/************************************************************************/
/* Type definition structures and manipulation functions		*/
/************************************************************************/

struct named_type		/* type definition table structure	*/
  {
  DBL_LNK      link;		/* generic list links			*/
  ST_CHAR type_name[MAX_IDENT_LEN+1]; 	/* name of data type		*/
  ST_BOOLEAN   deletable;	/* set != 0 if deletable		*/
  ST_UCHAR     protection;	/* protection afforded for type		*/
  ST_BOOLEAN   erased; 		/* flags if deleted, but nref !=0	*/
  ST_INT       nref;		/* number of var def'ns referencing this*/
  RUNTIME_CTRL *rt_ctrl;	/* May be NULL				*/
  RUNTIME_TYPE *rt_head; 	/* ptr to runtime type def head 	*/
  ST_INT       rt_num; 		/* # of rt_blocks in runtime type def	*/
  ST_INT       asn1len;		/* # bytes in ASN.1 definition		*/
  ST_UCHAR     *asn1ptr;	/* pointer to ASN.1 definition		*/
  ST_INT       blocked_len;	/* length of blocked (packed) data type */
  ST_CHAR *(*read_ind_fun)(ST_CHAR *src, ST_INT len);  /* std read ind function ptr */
  ST_INT (*write_ind_fun)(ST_CHAR *src, ST_CHAR *dest, ST_INT len); /* std write ind	*/
  };
typedef struct named_type NAMED_TYPE;

ST_RET ms_locl_to_asn1_aa (ASN1_ENC_CTXT *aCtx, NAMED_TYPE *tptr, 
                          ALT_ACCESS *alt_acc,
			  ST_CHAR *dptr);

ST_RET ms_asn1_to_locl_aa (NAMED_TYPE *tptr,
                          ALT_ACCESS *alt_acc,
                          ST_UCHAR *asn1ptr,
                          ST_INT asn1len,
                          ST_CHAR *dptr);

extern ST_INT max_mmsease_types;	   /* max number allowed	*/
extern ST_INT mms_type_count;		   /* number currently defined	*/

NAMED_TYPE *ms_add_named_type (DOMAIN_OBJS *dom, ST_CHAR *name,
				ST_UCHAR *asn1, ST_INT asn1len);
NAMED_TYPE *ms_find_named_type_obj (OBJECT_NAME *obj, 
					ST_INT chan);
NAMED_TYPE *ms_find_named_type (DOMAIN_OBJS *dom,ST_CHAR *name);
ST_RET ms_del_named_type (DOMAIN_OBJS *dom,ST_CHAR *name);
ST_RET ms_del_type (DOMAIN_OBJS *dom, NAMED_TYPE *name);
ST_VOID  ms_del_all_named_types (DOMAIN_OBJS *dom_objs);
ST_RET ms_del_named_type_obj (OBJECT_NAME *obj, ST_INT chan);
ST_RET ms_add_std_types (DOMAIN_OBJS *dom);

ST_CHAR *rdind_fun (ST_CHAR *addr, ST_INT len);
ST_RET wrind_fun (ST_CHAR *data, ST_CHAR *addr, ST_INT len);

ST_RET mv_gettype_resp (MMSREQ_IND *ind);
ST_RET mv_gettype_resp (MMSREQ_IND *ind);
ST_RET mv_deltype_resp (MMSREQ_IND *ind);
ST_RET mv_deftype_resp (MMSREQ_IND *ind);


/************************************************************************/
/* Variable definition structures and manipulation functions		*/
/************************************************************************/

struct	named_var			/* name table structure 	*/
  {
  DBL_LNK      link;			/* generic list links		*/
  ST_CHAR      varname[MAX_IDENT_LEN+1];/* variable name		*/
  ST_BOOLEAN   invalid;			/* variable invalidated due	*/
					/* to type or addr deleted	*/
  NAMED_TYPE   *type;		   	/* type name/domain		*/
  ST_BOOLEAN   deletable;		/* != 0 if deletable 		*/
  ST_UCHAR     rd_pro;			/* read protection		*/
  ST_UCHAR     wr_pro;			/* write protection		*/
  VAR_ACC_ADDR addr;		   	/* address			*/
  ST_CHAR *(*read_ind_fun)(ST_CHAR *src, ST_INT len);  /* std read ind function ptr */
  ST_INT (*write_ind_fun)(ST_CHAR *src, ST_CHAR *dest, ST_INT len); /* std write ind	*/
/* Followed by the address, for symbolic or unconstrained address      */
/* types. The length of this address is determined when the var  added */
  SD_END_STRUCT
  };
typedef struct named_var NAMED_VAR;

struct	named_var_list		/* name variable list structure		*/
  {					
  DBL_LNK    link;			/* generic list links		*/
  ST_CHAR    name[MAX_IDENT_LEN+1];	/* variable list name		*/
  ST_BOOLEAN deletable;			/* != 0 if deletable 		*/
  ST_INT     num_vars;		/* # of vars in Named Variable List.	*/
  /* VARIABLE_LIST var_list [num_of_variables];				*/ 
  SD_END_STRUCT
  };
typedef struct named_var_list NAMED_VAR_LIST;

extern ST_INT  max_mmsease_vars;	/* max number allowed		*/
extern ST_INT  mms_var_count;		/* number currently defined	*/
extern ST_INT  max_mmsease_nvlists;
extern ST_INT  mms_nvlist_count;

/************************************************************************/
/* This function selects the binary search mechansisms (default)	*/
ST_VOID ms_bs_init (ST_VOID);

/* This function selects the linked list search mechansisms		*/
ST_VOID ms_ll_init (ST_VOID);

NAMED_VAR *ms_add_named_var (DOMAIN_OBJS *dom, ST_CHAR *name,
	                     OBJECT_NAME *type, VAR_ACC_ADDR *addr, 
			     ST_INT chan);
NAMED_VAR *ms_add_var (DOMAIN_OBJS *dom, ST_CHAR *name,
	               NAMED_TYPE *type, VAR_ACC_ADDR *addr, ST_INT chan);

NAMED_VAR *ms_find_named_var (DOMAIN_OBJS *dom, ST_CHAR *name);
NAMED_VAR *ms_find_named_var_obj (OBJECT_NAME *obj, ST_INT chan);

ST_RET ms_del_named_var (DOMAIN_OBJS *dom, ST_CHAR *name);
ST_RET ms_del_named_var_obj (OBJECT_NAME *obj, ST_INT chan);

ST_VOID  ms_del_all_named_vars    (DOMAIN_OBJS *dom);

NAMED_VAR_LIST *ms_add_nvlist (DOMAIN_OBJS *dom, ST_CHAR *name, 
                               ST_INT num_vars, VARIABLE_LIST *var_list);
NAMED_VAR_LIST *ms_find_nvlist (DOMAIN_OBJS *dom, ST_CHAR *name);
NAMED_VAR_LIST *ms_find_nvlist_obj (OBJECT_NAME *obj, ST_INT chan);

ST_RET ms_del_nvlist (DOMAIN_OBJS *dom, ST_CHAR *name);
ST_RET ms_del_nvlist_obj (OBJECT_NAME *obj, ST_INT chan);

ST_VOID  ms_del_all_nvlists (DOMAIN_OBJS *dom);

ST_RET mv_getvar_resp (MMSREQ_IND *ind);
ST_RET mv_delvar_resp (MMSREQ_IND *ind);
ST_RET mv_defvar_resp (MMSREQ_IND *ind);
ST_RET mv_namelist_resp	(MMSREQ_IND *ind);

ST_RET mv_getvlist_resp (MMSREQ_IND *ind);
ST_RET mv_delvlist_resp (MMSREQ_IND *ind);
ST_RET mv_defvlist_resp (MMSREQ_IND *ind);

/************************************************************************/
/* VIRTUAL MACHINE READ, WRITE, INFORMATION REPORT			*/
/* The structure below are used for most variable access VM req funs,	*/
/* and allows multiple variables per transaction.			*/
/************************************************************************/
/* VM defines to be used for DataAccessError codes		      	*/
#define ERROR_RESPONSE		20	/* for error response only 	*/
#define NUM_VAR_MISMATCH	21	


struct mv_vardesc 		/* virtual machine variable description	*/
  {
  OBJECT_NAME name;			/* name of variable		*/
  OBJECT_NAME type;			/* type of variable		*/
  ST_CHAR     *data;			/* destination/source pointer	*/
  };
typedef struct mv_vardesc MV_VARDESC;

/* This structure is provided as request information for a MV read req.	*/
/* If desired, this info may be examined in the user confirm function.	*/

struct readvars_req_info
  {				/* virtual machine read req structure	*/
  ST_INT  num_of_vars;			/* number of variables		*/
/*					   list of variables		*/
/* MV_VARDESC vardesc_list [num_of_vars];				*/
  SD_END_STRUCT
  };
typedef struct readvars_req_info READVARS_REQ_INFO;


/***** READ REQUEST ****						*/

/* a pointer to an array of these structures are passed into the 	*/
/* 'mv_read_variables' function						*/

struct mv_read_req_info
  {
  struct			/* input (request) information		*/
    {
    ST_CHAR    *data_ptr;	/* Dest data buffer (for success)	*/
    NAMED_TYPE *type;	 	/* pointer to associated type		*/
    ST_BOOLEAN alt_acc_pres;	/* set SD_TRUE if Alt Access is present	*/
    ST_BOOLEAN alt_acc_type_aa;	/* set SD_TRUE if type is Alt Acc ready	*/
    ST_BOOLEAN alt_acc_data_packed; /* set SD_TRUE if local data is packed	*/
    ALT_ACCESS alt_acc; 	/* Alternate Access specification	*/
    }i;
  struct			/* output (result) information		*/
    {
    ST_RET   result;     	/* !=0 for success, else SD_FAILURE	*/
    ST_INT16 err_code;		/* DataAccessError (for failure)	*/

/* If a named type is not supplied, and the read was a success, this	*/
/* is the derived runtime type. It was allocated using 'chk_calloc'	*/
/* and must be free'd using 'chk_free'					*/

    ST_INT       num_rt;		
    RUNTIME_TYPE *rt_out;	

/* If a data_ptr is not supplied, and the read was a success, this	*/
/* is the buffer allocated for the data. It was allocated using 	*/
/* 'chk_calloc'	and must be free'd using 'chk_free'			*/

    ST_CHAR      *data_ptr_out;	 /* Dest data buffer (for success)	*/
    }o;
  };
typedef struct mv_read_req_info	MV_READ_REQ_INFO;

MMSREQ_PEND *mv_read (ST_INT chan, OBJECT_NAME *name, 
		      OBJECT_NAME *type, ST_CHAR *dest);
MMSREQ_PEND *mv_readvars (ST_INT chan, ST_INT num_var, MV_VARDESC *info);
MMSREQ_PEND *mv_read_variables (ST_INT chan, ST_INT num_var, 
				READ_REQ_INFO *prim, 
				MV_READ_REQ_INFO *vminfo);

/***** READ RESPONSE  *****						*/

/* a pointer to an array of these structures are passed into the 	*/
/* 'mv_read_response' function						*/

struct mv_read_resp_info
  {
  ST_INT16   result; 		/* ACC_RSLT_SUCCESS, ACC_RSLT_FAILURE	*/
  ST_INT16   err_code;		/* DataAccessError (for failure)	*/
  ST_CHAR    *data_ptr;		/* Source data buffer (for success)	*/
  NAMED_TYPE *type;		/* pointer to associated type		*/
  ST_BOOLEAN alt_acc_pres;	/* set SD_TRUE if Alt Access is present	*/
  ST_BOOLEAN alt_acc_data_packed;/* set SD_TRUE if local data is packed	*/
  ALT_ACCESS alt_acc; 		/* Alternate Access specification	*/
  };
typedef struct mv_read_resp_info MV_READ_RESP_INFO;

ST_RET mv_read_resp (MMSREQ_IND *ind);
ST_RET mv_read_response (MMSREQ_IND *ind, ST_INT num_var, 
			 MV_READ_RESP_INFO *info);

/***** WRITE REQUEST  ****						*/

/* a pointer to an array of these structures are passed into the 	*/
/* 'mv_write_variables' function					*/

struct mv_write_req_info
  {
  ST_CHAR    *data_ptr;		/* Source data buffer 			*/
  NAMED_TYPE *type;		/* pointer to associated type		*/
  ST_BOOLEAN alt_acc_pres;	/* set SD_TRUE if Alt Access is present	*/
  ST_BOOLEAN alt_acc_type_aa;	/* set SD_TRUE if type is Alt Acc ready	*/
  ST_BOOLEAN alt_acc_data_packed;/* set SD_TRUE if local data is packed	*/
  ALT_ACCESS alt_acc; 		/* Alternate Access specification	*/
  };
typedef struct mv_write_req_info MV_WRITE_REQ_INFO;

MMSREQ_PEND *mv_write (ST_INT chan, OBJECT_NAME *var, 
	               OBJECT_NAME *type, ST_CHAR *src);
MMSREQ_PEND *mv_writevars (ST_INT chan, ST_INT num_var, MV_VARDESC *info);
MMSREQ_PEND *mv_write_variables (ST_INT chan, ST_INT num_data, 
				 VAR_ACC_SPEC *reqinfo,
				 MV_WRITE_REQ_INFO *vminfo);

/***** WRITE RESPONSE ****						*/

ST_RET mv_write_resp (MMSREQ_IND *ind);
WRITE_RESP_INFO *mv_write_decode (MMSREQ_IND *indptr);
ST_RET ms_extract_write_data (MMSREQ_IND *ind, ST_INT index, 
			      NAMED_TYPE *type,
			      ST_CHAR *dest, ST_BOOLEAN alt_acc_packed);

ST_RET ms_extract_wr_data (MMSREQ_IND *indptr, ST_INT i,
			   NAMED_TYPE *type, ST_CHAR *dest, 
			   ST_BOOLEAN alt_acc_packed, ALT_ACCESS *alt_acc_ptr);

/***** INFORMATION REPORT REQUEST *****					*/

/* a pointer to an array of these structures are passed into the 	*/
/* 'mv_info_req' function						*/

struct mv_info_req_info
  {
  ST_CHAR    *data_ptr;		/* Source data buffer 			*/
  NAMED_TYPE *type;		/* pointer to associated type		*/
  ST_BOOLEAN alt_acc_pres;	/* set SD_TRUE if Alt Access is present	*/
  ST_BOOLEAN alt_acc_data_packed;/* set SD_TRUE if local data is packed	*/
  ALT_ACCESS alt_acc; 		/* Alternate Access specification	*/
  };
typedef struct mv_info_req_info	MV_INFO_REQ_INFO;

ST_RET mv_info (ST_INT chan, OBJECT_NAME *var, OBJECT_NAME *type, 
                ST_CHAR *src);
ST_RET mv_infovars (ST_INT chan, ST_INT num_vars, MV_VARDESC *vminfo);
ST_RET mv_info_report (ST_INT chan, VAR_ACC_SPEC *req,
		       ST_INT num_var, MV_INFO_REQ_INFO *vminfo);
ST_RET mv_info_nvlist (ST_INT chan, OBJECT_NAME *obj);

ST_RET ms_extract_info_data (MMSREQ_IND *ind, ST_INT index, 
	                     NAMED_TYPE *type, ST_CHAR *dest, 
			     ST_BOOLEAN alt_acc_packed);

ST_RET ms_extract_inf_data (MMSREQ_IND *indptr, ST_INT i,
			    NAMED_TYPE *type, ST_CHAR *dest, 
			    ST_BOOLEAN alt_acc_packed, 
			    ALT_ACCESS *alt_acc_ptr);

/************************************************************************/

OBJECT_NAME *ms_extract_varname (ST_CHAR *reqinfo, ST_INT op, ST_INT indx);

/************************************************************************/
/************************************************************************/
#endif /* end of MMS_LITE not defined					*/
/************************************************************************/
/************************************************************************/

#define MMS_EASE_BUILDER	0
#define UNKNOWN_BUILDER		1

extern ST_INT ms_req_bld_id;
extern ST_INT ms_resp_bld_id;

ST_RET ms_init_va_size (ST_INT chan, ST_UCHAR spec_in_rslt, 
			ST_INT16 var_acc_tag, OBJECT_NAME *vl_name, 
			ST_LONG *req_size_out, ST_LONG *resp_size_out);

#ifndef MMS_LITE
ST_RET ms_va_size (ST_INT op, ST_UCHAR spec_in_rslt, ST_INT16 var_acc_tag,
		   VARIABLE_LIST *vl, NAMED_TYPE *type,
		   ST_LONG *req_size_out, ST_LONG *resp_size_out);
#else
ST_RET ms_va_size (ST_INT op, ST_UCHAR spec_in_rslt, ST_INT16 var_acc_tag,
	VARIABLE_LIST *vl_ptr, ST_INT type_id,
	ST_LONG *req_size, ST_LONG *resp_size);
#endif

/************************************************************************/
/************************************************************************/

extern ST_INT m_rt_type_limit;      /* max num of runtime blks per def 	*/


#ifndef MMS_LITE
ST_INT ms_get_blocked_len (NAMED_TYPE *type);
#endif

ST_INT ms_get_blocked_length (SD_CONST RUNTIME_TYPE *rt, ST_INT num_rt);

ST_RET ms_runtime_to_asn1 (ASN1_ENC_CTXT *aCtx, SD_CONST RUNTIME_TYPE *rt, ST_INT num_rt);

ST_UCHAR *ms_mk_asn1_type (ST_INT *asn1_len, ST_UCHAR *asn1_buf, 
			   ST_CHAR *tdl);

ST_VOID ms_log_runtime (SD_CONST RUNTIME_TYPE *rt, ST_INT num_rt);

ST_CHAR *ms_asn1_to_tdl (ST_UCHAR *asn1_ptr, ST_INT asn1_len, 
			 ST_INT max_tdl_len);
ST_INT ms_runtime_to_tdl (SD_CONST RUNTIME_TYPE *rt, ST_INT rt_num,
			  ST_CHAR *tdl_buf, ST_INT max_tdl_len);

RUNTIME_CTRL *ms_tdl_to_runtime (ST_CHAR *tdl,	/* TDL string	*/
			ST_UCHAR *asn1_buf,	/* ASN.1 buffer	*/
			ST_INT asn1_buf_len);	/* buffer len	*/

ST_RET ms_rt_to_typedef (ST_CHAR *typedefName, SD_CONST RUNTIME_TYPE *rt,
				ST_INT numRt, ST_CHAR *dest, ST_INT destSize);

RUNTIME_CTRL *ms_runtime_create (ST_UCHAR *asn1_data,
			ST_UINT asn1_len,
			ST_INT max_num_rt);
ST_VOID ms_runtime_destroy (RUNTIME_CTRL *rt_head);

#if !defined(MMS_LITE)
/* For backward compatibility only.					*/
/* New programs should use ms_runtime_create.				*/

ST_INT ms_asn1_to_runtime_x (ST_UCHAR *asn1_data, ST_UINT asn1_len,
   		            RUNTIME_TYPE *rt_table, ST_INT rt_len, 
   		            ST_BOOLEAN calc_only);

#define ms_asn1_to_runtime(asn1,asn1_len,rt,num_rt)\
                   ms_asn1_to_runtime_x(asn1,asn1_len,rt, num_rt,m_calc_rt_size)

/* Note: This variable is no longer used internally by MMS-EASE, but 	*/
/* can be used in the application space for the following: 		*/
/*   1. Is used in the macro 'ms_asn1_to_runtime' for the 		*/
/*	'ms_asn1_to_runtime_x' calc_only parameter. This is done to 	*/
/* 	maintain backward compatibility, and users are encouraged to 	*/
/* 	use 'ms_runtime_create' instead.				*/
extern ST_BOOLEAN m_calc_rt_size; /* flag to calculate num rt blocks 	*/
				  /* in ms_asn1_to_runtime		*/
#endif /* !MMS_LITE	*/

/************************************************************************/
/*			ms_comp_name_find				*/
/* These macros find the component name in a runtime type structure.	*/
/* There are different macros for different RUNTIME_TYPE structures.	*/
/* Macro argument = ptr to RUNTIME_TYPE struct.				*/
/* RETURN: pointer to component name string				*/
/************************************************************************/
#if defined(USE_RT_TYPE_2)

/* rt->comp_name_ptr = pointer to string	*/
/* NOTE: ptr may be NULL. If so return empty string (i.e. "") instead	*/
/*       of NULL. Caller might not handle NULL.				*/
#define ms_comp_name_find(rt)	((rt)->comp_name_ptr ? (rt)->comp_name_ptr : "")
#define ms_comp_name_pres(rt)	((rt)->comp_name_ptr ? SD_TRUE : SD_FALSE)

#elif defined(USE_RT_TYPE_3)

/* rt->name_index = index to global array of strings "mvlRtNames"	*/
#define ms_comp_name_find(rt)	(mvlRtNames[(rt)->name_index])
#define ms_comp_name_pres(rt)	((rt)->name_index > 0 ? SD_TRUE : SD_FALSE)

#else	/* Default	*/

/* rt->name = character array.	*/
#define ms_comp_name_find(rt)	((rt)->name)
#define ms_comp_name_pres(rt)	((rt)->name[0] != 0 ? SD_TRUE : SD_FALSE)

#endif	/* Default	*/


/************************************************************************/
/* VIRTUAL MACHINE ASN.1 TO?FROM LOCAL REPRESENTATION FUNCTIONS		*/
/* These functions are used to translate ASN.1 encoded data to/from	*/
/* local format								*/
/************************************************************************/

#ifndef MMS_LITE
ST_RET ms_asn1_to_locl (NAMED_TYPE *type, 
			ST_UCHAR *asn1, ST_INT asn1_len, ST_CHAR *dest);
ST_RET ms_locl_to_asn1 (ASN1_ENC_CTXT *aCtx, NAMED_TYPE *type, ST_CHAR *src);
#endif

/* These 2 are Re-entrant functions. Based on ASN1R tools.	*/
ST_RET ms_asn1_to_local (SD_CONST RUNTIME_TYPE *rt, ST_INT num_rt,
			ST_UCHAR *asn1, ST_INT asn1_len, ST_CHAR *dest);
ST_RET ms_local_to_asn1 (ASN1_ENC_CTXT *aCtx,
			SD_CONST RUNTIME_TYPE *rt_head,
			ST_INT rt_num,
			ST_CHAR *dptr);
ST_UCHAR *ms_local_to_asn1_easy (SD_CONST RUNTIME_TYPE *rt_head, ST_INT rt_num,
			ST_CHAR *dptr,
                        ST_UCHAR *asn1Buf,
                        ST_INT asn1BufLen,
                        ST_INT *asn1LenOut);
ST_CHAR *ms_local_to_text (ST_CHAR *datptr, SD_CONST RUNTIME_TYPE *rt_head, ST_INT rt_num,
	ST_CHAR *textBuf, ST_UINT textBufSize);



/* Index definitions into the alignment table				*/
#define ARRSTRT_ALGN	 0
#define ARREND_ALGN	 1
#define STRSTRT_ALGN	 2
#define STREND_ALGN	 3
#define INT8_ALGN	 4
#define INT16_ALGN	 5
#define INT32_ALGN	 6
#define INT64_ALGN	 7
#define FLOAT_ALGN	 8
#define DOUBLE_ALGN	 9
#define OCT_ALGN	10
#define BOOL_ALGN	11
#define BCD1_ALGN	12
#define BCD2_ALGN	13
#define BCD4_ALGN	14
#define BIT_ALGN	15
#define VIS_ALGN	16

#define NUM_ALGN_TYPES 17
extern SD_CONST ST_INT *m_data_algn_tbl;
extern SD_CONST ST_INT m_packed_data_algn_tbl[NUM_ALGN_TYPES];
extern SD_CONST ST_INT m_def_data_algn_tbl[NUM_ALGN_TYPES];
extern ST_INT m_lite_data_algn_tbl[NUM_ALGN_TYPES];	/* created by Foundry	*/

#define M_STRSTART_MODE_NONE 	0
#define M_STRSTART_MODE_FIRST 	1
#define M_STRSTART_MODE_LARGEST	2
extern ST_INT m_struct_start_algn_mode;

#define M_STREND_MODE_NONE 	0
#define M_STREND_MODE_LARGEST	1
extern ST_INT m_struct_end_algn_mode;

/* User defined runtime type post processing function			*/
extern ST_VOID (*u_rt_type_process) (SD_CONST RUNTIME_TYPE *rt, ST_INT num_rt);


/************************************************************************/
/************************************************************************/

/* For encoding and decoding 'alternateAccess', the outer constructor	*/
/* usually has a value of 5. If a different value is required (for 	*/
/* scattered access, for instance), this value can be modified.		*/
/* Used in both encoding and decode of alternateAccess			*/
extern ST_INT16 m_alt_acc_outer_tag;

/* When decoding an ASN.1 alternateAccess, this variable determines the */
/* size of the table that is allocated for the decoded AA (and so 	*/
/* limits the complexity of the alternate access that can be handled	*/
/* The default value is 50.						*/
extern ST_INT m_max_dec_aa;

/* This variable is the 'high water' mark of how many AA were actually	*/
/* required. This can be used to tune memory usage if desired.		*/
extern ST_INT m_hw_dec_aa;

/* When performing ASN1 <-> local data format, the runtime type is 	*/
/* 'unrolled', and one element is required for each data element and	*/
/* structure/array start/end. This variable determines the size of the 	*/
/* of the table that is allocated for this operation (and so limits the */
/* size and complexity of the data types that can be handled.		*/
/* The default value is 1000.						*/
extern ST_INT m_max_rt_aa_ctrl;

/* This variable is the 'high water' mark of how many elements were	*/
/* actually required for m_max_rt_aa_ctrl. This can be used to tune 	*/
/* memory usage if desired.						*/
extern ST_INT m_hw_rt_aa_ctrl;

/* This variable is used to determine whether the local data format is 	*/
/* in 'packed type' or 'original type' form. Used in all conversions 	*/
/* to/from local data form when the AA_DATA library is used. 		*/
/* Temporarily set to SD_FALSE  for the non-AA data conversion functions.	*/
extern ST_BOOLEAN m_alt_acc_packed;

/************************************************************************/

extern ST_RET (*ms_asn1_data_to_runtime_fun) (RUNTIME_TYPE **tptr,
					      ST_INT *t_len,
					      ST_UCHAR *asn1ptr,
					      ST_INT asn1_len);

ST_RET ms_asn1_data_to_runtime (RUNTIME_TYPE **tptr,
				ST_INT *t_len,
				ST_UCHAR *asn1ptr,
				ST_INT asn1_len);

ST_RET ms_asn1_data_to_locl (ST_UCHAR *asn1_data,	   
		  	     ST_INT asn1_data_len, 
			     ST_VOID **data_dest,
			     ST_INT *data_dest_len,
			     RUNTIME_TYPE **rt,     
			     ST_INT *t_len);	   

ST_VOID ms_rt_size_calc (RUNTIME_TYPE *rt_head, ST_INT rt_num);

/************************************************************************/
/* ARBITRARY DATA HANDLING 						*/
/************************************************************************/

typedef struct m_arb_data_ctrl
  {
  ST_RET (*arrStart) (RT_AA_CTRL *rtaa);
  ST_RET (*arrEnd)   (RT_AA_CTRL *rtaa);
  ST_RET (*strStart) (RT_AA_CTRL *rtaa);
  ST_RET (*strEnd)   (RT_AA_CTRL *rtaa);
  ST_RET (*int8)     (ST_INT8    *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*int16)    (ST_INT16   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*int32)    (ST_INT32   *data_dest, RT_AA_CTRL *rtaa);
#ifdef INT64_SUPPORT
  ST_RET (*int64)    (ST_INT64   *data_dest, RT_AA_CTRL *rtaa);
#endif
  ST_RET (*uint8)    (ST_UINT8   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*uint16)   (ST_UINT16  *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*uint32)   (ST_UINT32  *data_dest, RT_AA_CTRL *rtaa);
#ifdef INT64_SUPPORT
  ST_RET (*uint64)   (ST_UINT64  *data_dest, RT_AA_CTRL *rtaa);
#endif
  ST_RET (*flt)      (ST_FLOAT   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*dbl)      (ST_DOUBLE  *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*oct)      (ST_UCHAR   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*booln)    (ST_BOOLEAN *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*bcd1)     (ST_INT8    *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*bcd2)     (ST_INT16   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*bcd4)     (ST_INT32   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*bs)       (ST_UCHAR   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*vis)      (ST_CHAR    *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*bt4)      (ST_INT32   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*bt6)      (ST_INT32   *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*gt)       (time_t     *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*utc)      (MMS_UTC_TIME *data_dest, RT_AA_CTRL *rtaa);
  ST_RET (*utf8)     (ST_UCHAR   *data_dest, RT_AA_CTRL *rtaa);
  } M_ARB_DATA_CTRL;

ST_RET ms_process_arb_data (ST_CHAR *data_base, 
			    SD_CONST RUNTIME_TYPE *rt_head, ST_INT rt_num,
		       	    ST_BOOLEAN alt_acc_pres, ST_BOOLEAN alt_acc_packed, 
			    ALT_ACCESS *alt_acc,
		            M_ARB_DATA_CTRL *ac);

#ifdef __cplusplus
}
#endif

#endif

