oioic.h

robot open source code

#define     FR_N_LACKOID         (FR_N_PRIVATE_ - 2)  /* __CreateObject__，没有足够的OID供分配。*/
#define     FR_N_HASVR           (FR_N_PRIVATE_ - 1)  /* CallerCome，已经有这个VR了。*/
#define     FR_N_LOST            (FR_N_PRIVATE_ - 0)  /* Enqueue/Dequeue，已丢失了Byte。*/
/* >#define     FR_N_PRIVATE_        (FR_N - x)  /-* <内部私有N结果的起点>*-/ */

#define     FR_N_PRIVATE_        (FR_N - 10)  /* <内部私有N结果的起点> */
#define     FR_N_INVALIDARG      (FR_N -1) /* 无效参数。*/
#define     FR_N        __FR_ON__  /* N结果（否定性结果）的起点。*/
#define     __FR_ON__       (FR_O_PVTN_ - 1000)  /* O结果域的N界。*/

#define     FR_O_PVTN_		(FR_O - 10)  /* <外部私有负O结果的起点> */

#define     FR_O_VAINLY			(FR_O - 1)  /* 空操作 */
#define     FR_O				0			/* O结果（中立性结果）域的中点。*/

#define     FR_O_PVTP_		(FR_O + 10)  /* <外部私有正O结果的起点> */

#define     __FR_OP__       (FR_O_PVTP_ + 1000)  /* O结果域的P界。*/
#define     FR_P         __FR_OP__   /* P结果（肯定性结果）的起点。*/
#define     FR_P_PRIVATE_        (FR_P + 10)  /* <内部私有P结果的起点> */

/* >#define     FR_P_PRIVATE_        (FR_P + x)  /-* <内部私有P结果的起点>*-/ */
#define     FR_P_PVT_            (FR_P_PRIVATE_ + 0)  /* <外部私有P结果的起点> */

/*
*
* 描述：函数执行结果否定性/中立性/肯定性检测定义。
* 备注：NFR --- Negative FRESULT；
*      OFR --- O  FRESULT；
*      PFR --- Positive FRESULT。
*/
#define     NFR(Result)      ( (FRESULT)(Result) <= __FR_ON__ )
#define     OFR(Result)      ( ((FRESULT)(Result) > __FR_ON__) && ((FRESULT)(Result) < __FR_OP__) )
#define     PFR(Result)      ( (FRESULT)(Result) >= __FR_OP__ )

/*
*
* 定义布尔值和空指针值。
*/
#undef TRUE
#undef FALSE
#undef NULL

#define TRUE          1      /* 布尔类型数据值：真 */
#define FALSE         0      /* 布尔类型数据值：假 */
#define NULL          0      /* 指针类型数据值：空 */


/*======================+  OIOIC  +======================*/

/*
 *
 * 描述：队列结构体
 * 备注：q_，pq_。
 */
typedef struct TAG_QUEUE
{
   BYTE*    Dtrm; /* Data Room，数据空间。*/
   BYTKTY   Cty;  /* Dtrm的容量。*/
   BYTE*    Front;  /* 当前第一个Byte数据的地址。*/
   BYTE*    Rear;  /* 当前最后一个Byte数据的地址。*/
   BYTKTY   Qty;  /* 当前Dtrm内存有的Byte数量。*/
   BYTKTY   Lost;  /* 因Dtrm已满而丢弃的Byte数量。*/
}QUEUE;


/*
 *
 * 描述：VR结构体。
 * 备注：vr_，pvr_。
 */
typedef struct TAG_VR
{
	OBJID    cr;  /* CR的ID。*/
	OBJID    mr;  /* MR的ID。*/
}VR;   

/*
 *
 * 描述：定义 EM 数据类型。
 * 备注：1. em_，pem_；
 *       2. 对象的实际扩展成员必须放在如下格式的EM结构体里，
 *			typedef struct TAG_EM_XXX
 *			{
 *				...
 *			}EM_XXX;
 */
typedef    VOID     EM;  /* 定义EM数据类型。*/


/*
 *
 * 描述：OIOIC对象模型结构体。
 * 备注：“OIOIC”是5个通用接口（Open，Input，Output，Interact，Close）的第一个字符的合写。
 */
typedef struct TAG_OBJECT
{   
   /* RefCnt，对象引用计数（Reference Count）。*/
   REFCNT     RefCnt;

   /* MSN，模的SN。*/  
   MLDSN      MSN;
   
   /* OID，对象的ID。*/  
   OBJID      OID; 
   
   /* 为了... 需要下面两个成员： 
   * po_AND：指向AND。
   * NND：the Number of ND of IC，IC的ND数量，也就是AND的元素数量。*/
   struct TAG_OBJECT*   po_AND; 
   NUMND      NND; 
   
   /* 为能高效率访问IBN，需要下面两个成员：
   * ppo_AIB：指向AIB数组。
   * NIB：the Number of IB，IB数量，即AIB的元素数量。*/
   struct TAG_OBJECT**  ppo_AIB;
   NUMIB      NIB; 
   
   /* 为了能访问BN的EM和高效率地清除来访记录，需要下面两个成员：
   * ppo_ABN：指向ABN数组。
   * NBN：the Number of BN，BN数量，即ABN的元素数量。*/
   struct TAG_OBJECT**  ppo_ABN;
   NUMBN	  NBN; 
   
   /* 不可重入（Not Reentrant）访问规则, 即同一MR的同一CR对每个BN只能访问一次。
   * 为遵守不可重入访问规则，需要下面两个成员：
   * pvr_ACS：指向ACS。
   * NCS：the Number of CS，CS的数量，即ACS的元素数量。*/
   VR*        pvr_ACS;
   NUMCS      NCS;    
   
   /** 对象接口：Open，Input，Output，IOput，Interact0~3，Close。**/
   
   /* 名称：Open
   *  描述：打开。
   *  参数：pCaller --- [IN] 来访者。*/
   IRESULT  (*Open) (struct TAG_OBJECT* This, const VR* pCaller);
   /* 名称：Input
   *  描述：输入。
   *  参数：IStrm --- [IN] 输入流；
   *        Qty --- [IN] 输入的Byte数量；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*Input) (struct TAG_OBJECT* This, BYTE* IStrm, BYTKTY Qty, const VR* pCaller);
   /* 名称：Output
   *  描述：输出。
   *  参数：OStrm --- [OUT] 输出流的流向；
   *        Cty --- [IN] OStrm所指存储空间的容量；
   *        pQty --- [OUT] 指向实际输出的Byte数量；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*Output) (struct TAG_OBJECT* This, BYTE* OStrm, BYTKTY Cty, BYTKTY* pQty, const VR* pCaller);
   /* 名称：IOput
   *  描述：输入输出。
   *  参数：IStrm --- [IN] 输入流；
   *        Qty --- [IN] 输入的Byte数量；
   *        OStrm --- [OUT] 输出流的流向；
   *        Cty --- [IN] OStrm所指存储空间的容量；
   *        pQty --- [OUT] 指向实际输出的Byte数量；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*IOput) (struct TAG_OBJECT* This, BYTE* IStrm, BYTKTY Qty, BYTE* OStrm, BYTKTY Cty, BYTKTY* pQty, const VR* pCaller);
   /* 名称：Interact0
   *  描述：交互，接收AC0类型的行为。
   *  参数：Act --- [IN] 交互行为；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*Interact0) (struct TAG_OBJECT* This, ACTION Act, const VR* pCaller);
   /* 名称：Interact1
   *  描述：交互，接收AC1类型的行为。
   *  参数：Act --- [IN] 交互行为；
   *        OStrm --- [OUT] 输出流的流向；
   *        Cty --- [IN] OStrm所指存储空间的容量；
   *        pQty --- [OUT] 指向实际输出的Byte数量；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*Interact1) (struct TAG_OBJECT* This, ACTION Act, BYTE* OStrm, BYTKTY Cty, BYTKTY* pQty, const VR* pCaller);
   /* 名称：Interact2
   *  描述：交互，接收AC2类型的行为。
   *  参数：Act --- [IN] 交互行为；
   *        IStrm --- [IN] 输入流；
   *        Qty --- [IN] 输入的Byte数量；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*Interact2) (struct TAG_OBJECT* This, ACTION  Act, BYTE* IStrm, BYTKTY Qty, const VR* pCaller);
   /* 名称：Interact3
   *  描述：交互，接收AC3类型的行为。
   *  参数：Act --- [IN] 交互行为；
   *        IStrm --- [IN] 输入流；
   *        Qty --- [IN] 输入的Byte数量；
   *        OStrm --- [OUT] 输出流的流向；
   *        Cty --- [IN] OStrm所指存储空间的容量；
   *        pQty --- [OUT] 指向实际输出的Byte数量；
   *        pCaller --- [IN] 来访者。*/
   IRESULT  (*Interact3) (struct TAG_OBJECT* This, ACTION Act, BYTE* IStrm, BYTKTY Qty, BYTE* OStrm, BYTKTY Cty, BYTKTY* pQty, const VR* pCaller);
   /* 名称：Close
   *  描述：关闭。
   *  参数：pCaller --- [IN] 来访者。*/
   IRESULT  (*Close) (struct TAG_OBJECT* This, const VR* pCaller);
   
   /* pEM，指向对象的EM（扩展成员）。*/
   EM*   pEM;   
}OBJECT;

/*=====================+ OIOIC的EM +=====================*/

typedef struct TAG_EM_OIOIC
{ 
	QUEUE	   IQ;	/* 输入队列。*/  
	QUEUE	   OQ;  /* 输出队列。*/  
	MODES      mds;	/* 模式集。*/
}EM_OIOIC;

/*=============+  宏封装单个Byte入列和出列  +============*/

/* 单个Byte入列有两种模式：
*  1. PLACE --- 放入模式，向有空闲空间的队列放入一个Byte；
*  2. PUSH --- 推入模式，向已满（没有空闲空间）的队列推入一个Byte，把第一个Byte挤出扔掉。*/

/*
 *
 * 名称：ENQ_PLACE_BYTE
 * 描述：宏，向有空闲空间的队列放入一个Byte。
 * 参数：pQ --- [IN] QUEUE类型指针，指向队列，这个队列必须是有空闲空间的； 
 *       byte --- [IN] 入列的Byte。
 * 备注：只有在队列有空闲空间时才能使用。如下，
 *
 *		 if(pQ->Qty < pQ->Cty)
 *		 { 
 *		  	ENQ_PLACE_BYTE(pQ, byte);
 *		 }else
 *		 {
 *		 	pQ->Lost++; 
 * 
 *	 		/-* ... *-/
 *		 }
 */
#define  ENQ_PLACE_BYTE(pQ, byte) \
	do{ \
		if((pQ)->Rear == (pQ)->Dtrm + (pQ)->Cty - 1) \
			(pQ)->Rear = (pQ)->Dtrm; \
		else \
			(pQ)->Rear++; \
		*((pQ)->Rear) = (byte); \
		(pQ)->Qty++; \
		if((pQ)->Dtrm-1 == (pQ)->Front) \
			(pQ)->Front = (pQ)->Dtrm; \
	}while(0)

/*
 *
 * 名称：ENQ_PUSH_BYTE
 * 描述：宏，向已满（没有空闲空间）的队列推入一个Byte，把第一个Byte挤出扔掉。
 * 参数：pQ --- [IN] QUEUE类型指针，指向队列；
 *       byte --- [IN] 入列的Byte。
 * 备注：只有在队列已满时才能使用。如下，
 *
 *	  	 if(pQ->Qty < pQ->Cty)
 *		 {
 *			ENQ_PLACE_BYTE(pQ, byte);
 *		 }else
 *		 {
 *		 	ENQ_PUSH_BYTE(pQ, byte);
 *		 	pQ->Lost++; 
 * 
 *			/-* ... *-/
 *		 }
 */
#define  ENQ_PUSH_BYTE(pQ, byte) \
	do{ \
		(pQ)->Rear = (pQ)->Front; \
		*((pQ)->Rear) = (byte); \
		if( (pQ)->Front == ((pQ)->Dtrm + (pQ)->Cty -1) ) \
			(pQ)->Front = (pQ)->Dtrm; \
		else \
			(pQ)->Front++; \
	}while(0)

/*
 *
 * 名称：DEQ_BYTE
 * 描述：宏，从非空的队列出列一个Byte。
 * 参数：pQ --- [IN] QUEUE类型指针，指向队列；
 *       pByte --- [OUT] Byte地址，输出出列的Byte。
 * 备注：只有在队列非空时才能使用。如下，
 *
 *	  	 if(pQ->Qty > 0)
 *		 {
 *			DEQ_BYTE(pQ, pByte);
 *		 }
 */
#define  DEQ_BYTE(pQ, pByte) \
	do{ \
		*(pByte) = *((pQ)->Front); \
		(pQ)->Qty--; \
		if(0 == (pQ)->Qty) \
			(pQ)->Front = (pQ)->Rear = (pQ)->Dtrm -1; \
		else if( (pQ)->Front == ((pQ)->Dtrm + (pQ)->Cty -1) ) \
			(pQ)->Front = (pQ)->Dtrm; \
		else \
			(pQ)->Front++; \
	}while(0)


/*===================+  内联VO函数  +====================*/

/* 注：内联VO函数和非内联VO函数的功能是完全相同的。*/


#if INLINE_VOFUNCTION == 1

/**
 *
 * 名称：VO_Open
 * 描述：接口Open的VO函数。
 * 参数：pObject --- [IN] 指向对象；
 *       pCaller --- [IN] 来访者。
 */    	             
static  _INLINE_  IRESULT VO_Open(OBJECT* pObject, const VR* pCaller)
{
	extern  FRESULT CallerCome(OBJECT* pND, const VR* pCaller);
	extern  FRESULT CallerLeave(OBJECT* pND, const VR* pCaller);

	IRESULT  ir = IR_O;

	if( 0 == pCaller->cr || 0 == pCaller->mr )
		return IR_N_INVALIDARG;
	
	if( FR_P == CallerCome(pObject, pCaller) )
	{
		ir = pObject->Open(pObject, pCaller);
		CallerLeave(pObject, pCaller);
	}else { ir = IR_N; }
	
	return ir;
}
       
/**
 *
 * 名称：VO_Input
 * 描述：接口Input的VO函数。
 * 参数：pObject --- [IN] 指向对象； 
 *      IStrm --- [IN] 输入流；
 *      Qty --- [IN] 输入的Byte数量；
 *      pCaller --- [IN] 来访者。
 */          
static  _INLINE_  IRESULT VO_Input(OBJECT* pObject, BYTE* IStrm, BYTKTY Qty, const VR* pCaller)
{
	extern  FRESULT CallerCome(OBJECT* pND, const VR* pCaller);
	extern  FRESULT CallerLeave(OBJECT* pND, const VR* pCaller);

	IRESULT  ir = IR_O;

	if( NULL == IStrm || 0 == Qty || 0 == pCaller->cr || 0 == pCaller->mr )
		return IR_N_INVALIDARG;

	if( FR_P == CallerCome(pObject, pCaller) ) 
	{ 
		ir = pObject->Input(pObject, IStrm, Qty, pCaller); 
		CallerLeave(pObject, pCaller); 
	}else { ir = IR_N; }
	
	return ir;
}

/**
 *
 * 名称：VO_Output
 * 描述：接口Output的VO函数。
 * 参数：pObject --- [IN] 指向对象； 
 *      OStrm --- [OUT] 输出流的流向；
 *      Cty --- [IN] OStrm所指存储空间的容量；
 *      pQty --- [OUT] 指向实际输出的Byte数量；
 *      pCaller --- [IN] 来访者。
 */      
static  _INLINE_  IRESULT VO_Output(OBJECT* pObject, BYTE* OStrm, BYTKTY Cty, BYTKTY* pQty, const VR* pCaller) 
{
	extern  FRESULT CallerCome(OBJECT* pND, const VR* pCaller);
	extern  FRESULT CallerLeave(OBJECT* pND, const VR* pCaller);

	IRESULT  ir = IR_O;

	if( NULL == OStrm || 0 == Cty || NULL == pQty || 0 == pCaller->cr || 0 == pCaller->mr )
		return IR_N_INVALIDARG;

	*pQty = 0;

	if( FR_P == CallerCome(pObject, pCaller) ) 
	{ 
		ir = pObject->Output(pObject, OStrm, Cty, pQty, pCaller); 
		CallerLeave(pObject, pCaller); 
	}else { ir = IR_N; }
	
	return ir;
}

/**
*
* 名称：VO_IOput
* 描述：接口IOput的VO函数。
*  参数：IStrm --- [IN] 输入流；
*        Qty --- [IN] 输入的Byte数量；
*        OStrm --- [OUT] 输出流的流向；
*        Cty --- [IN] OStrm所指存储空间的容量；
*        pQty --- [OUT] 指向实际输出的Byte数量；
*        pCaller --- [IN] 来访者。
*/  
static  _INLINE_  IRESULT VO_IOput(OBJECT* pObject, BYTE* IStrm, BYTKTY Qty, BYTE* OStrm, BYTKTY Cty, BYTKTY* pQty, const VR* pCaller)
{
	extern  FRESULT CallerCome(OBJECT* pND, const VR* pCaller);
	extern  FRESULT CallerLeave(OBJECT* pND, const VR* pCaller);
	
	IRESULT  ir = IR_O;

	if( NULL == IStrm || 0 == Qty || NULL == OStrm || 0 == Cty || NULL == pQty || 0 == pCaller->cr || 0 == pCaller->mr )
		return IR_N_INVALIDARG;
	
	*pQty = 0;

	if( FR_P == CallerCome(pObject, pCaller) ) 
	{ 
		ir = pObject->IOput(pObject, IStrm, Qty, OStrm, Cty, pQty, pCaller); 
		CallerLeave(pObject, pCaller); 
	}else { ir = IR_N; }
	
	return ir;
}

/**
 *