写了有关缓冲区定义和访问的程序，可实现FIFO和LIFO功能

//定义数据类型
typedef        unsigned char         BOOLEAN;
typedef        unsigned char         INT8U;
typedef        signed char         INT8S;
typedef        unsigned int         INT16U;
typedef        signed int         INT16S;
typedef        unsigned long         INT32U;
typedef        signed long         INT32S;
typedef        float                   FP32;
typedef        double                FP64;

typedef         INT8S                BYTE;
typedef        INT8U                UBYTE;
typedef        INT16S                WORD;
typedef        INT16U                UWORD;
typedef        INT32U                ULONG;
typedef        INT32S                LONG;
typedef        FP32                FP;
typedef        FP64                DFP;

//定义常熟，表示缓冲器访问函数返回的缓冲器的状态
#define                BUFFER_NO_ERR        0                /*缓冲器无错*/
#define                BUFFER_FULL        1                /*缓冲器满*/
#define                BUFFER_FLUSH        2                /*缓冲器空*/

//定义缓冲器控制块的数据类型
typedef        struct
{
        void        *BuffStart;        //指向缓冲器的起始单元的地址
        void        *BuffEnd;                //执行缓冲器的结束单元的下一个地址
        void        *MemberIn;        //插入成员的指针
        void        *MemberOut;        //取出成员的指针(在LIFO方式下也是插入成员的指针)(取出成员时总是从该指针指向的地址取出)
        UWORD        BuffSize;                //缓冲区大小(成员总数)
        UWORD        BuffEntries;        //可使用的成员数
        UWORD        MemberSizeof;        //成员的类型
} STR_BufferCB;                        //缓冲器控制块类型定义

//定义初始化缓冲器控制块的函数：参数1－控制块指针；参数2－缓冲器的首地址；参数3－缓冲器大小(最大成员数)；参数4－成员数据类型，可由sizeof函数得到
void        InitBufferCB(STR_BufferCB *pbcb,void *pbufs,UWORD bsize,UWORD bsizeof)
{

        pbcb->BuffStart=(void *)pbufs;
        pbcb->MemberIn=(void *)pbufs;
        pbcb->MemberOut=(void *)pbufs;
        pbcb->BuffSize=bsize;
        pbcb->MemberSizeof=bsizeof;
        pbcb->BuffEntries=bsize;
        pbcb->BuffEnd=(void *)((UBYTE *)pbufs+bsize*bsizeof);
}
//定义晴空缓冲器控制块的函数：参数－控制块指针
void        BufferCBFlush(STR_BufferCB *pbcb)
{
        pbcb->BuffEntries=pbcb->BuffSize;
        pbcb->MemberOut=pbcb->MemberIn;
}
//定义缓冲器中放入一个成员的函数(FIFO方式)：参数1－控制块指针；参数2－指向成员的指针
UWORD        BufferMemberPush(STR_BufferCB *pbcb,void *pmenber)        //FIFO
{
        UBYTE        *psrc;
        UBYTE        *pdest;
        UWORD        i;
        
        if(pbcb->BuffEntries==0)
                {
                return(BUFFER_FULL);
                }

        psrc=(UBYTE *)pmenber;
        pdest=(UBYTE *)(pbcb->MemberIn);

        for(i=0;i<pbcb->MemberSizeof;i++)
                {
                *pdest++=*psrc++;
                }

        pbcb->BuffEntries--;
        pbcb->MemberIn=(void *)pdest;
        
        if(pbcb->MemberIn==pbcb->BuffEnd)
                {
                pbcb->MemberIn=pbcb->BuffStart;
                }
        return(BUFFER_NO_ERR);
}
//定义缓冲器中放入一个成员的函数(LIFO方式)：参数1－控制块指针；参数2－指向成员的指针
UWORD        BufferMemberPushFront(STR_BufferCB *pbcb,void *pmenber)        //LIFO
{
        UBYTE        *psrc;
        UBYTE        *pdest;
        UWORD        i;
        
        if(pbcb->BuffEntries==0)
                {
                return(BUFFER_FULL);
                }

        if(pbcb->MemberOut==pbcb->BuffStart)
                {
                pbcb->MemberOut=pbcb->BuffEnd;
                }

        pdest=(UBYTE *)(pbcb->MemberOut);
        pdest=pdest-(pbcb->MemberSizeof);
        pbcb->MemberOut=(void *)pdest;
        psrc=(UBYTE *)pmenber;
        
        for(i=0;i<pbcb->MemberSizeof;i++)
                {
                *pdest++=*psrc++;
                }
        pbcb->BuffEntries--;

        return(BUFFER_NO_ERR);
}
//定义从缓冲区中取出一个成员的函数：参数1－控制块指针；参数2－保存取出来的成员的变量的指针
UWORD        BufferMemberPop(STR_BufferCB *pbcb,void *pmenber)
{
        UBYTE        *psrc;
        UBYTE        *pdest;
        UWORD        i;
        
        if(pbcb->BuffEntries>=pbcb->BuffSize)
                {
                return(BUFFER_FLUSH);
                }

        pdest=(UBYTE *)pmenber;
        psrc=(UBYTE *)(pbcb->MemberOut);
        
        for(i=0;i<pbcb->MemberSizeof;i++)
                {
                *pdest++=*psrc++;
                }
                
        pbcb->BuffEntries++;

        pbcb->MemberOut=(void *)psrc;

        if(pbcb->MemberOut==pbcb->BuffEnd)
                {
                pbcb->MemberOut=pbcb->BuffStart;
                }

        return(BUFFER_NO_ERR);
}
//得到缓冲器的大小(最大成员数)
UWORD        GetBufferSize(STR_BufferCB *pbcb)
{
        return(pbcb->BuffSize);
}
//得到缓冲器的可以使用的成员数
UWORD        GetBufferEntries(STR_BufferCB *pbcb)
{
        return(pbcb->BuffEntries);
}
//得到缓冲器的成员的数据类型
UWORD        GetBufferSizeof(STR_BufferCB *pbcb)
{
        return(pbcb->MemberSizeof);
}
//得到缓冲器的首地址
void *        GetBufferStartAddr(STR_BufferCB *pbcb)
{
        return(pbcb->BuffStart);
}
//得到缓冲器的最后一个成员的下一个单元的地址
void *        GetBufferEndAddr(STR_BufferCB *pbcb)
{
        return(pbcb->BuffEnd);
}
//得到缓冲器的在FIFO方式下插入下一个成员的地址
void *        GetBufferInAddr(STR_BufferCB *pbcb)
{
        return(pbcb->MemberIn);
}
//得到缓冲器的在LIFO方式下插入下一个成员的地址
void *        GetBufferInAddrFront(STR_BufferCB *pbcb)
{
        UBYTE        *pdest;
        void        *ptemp;
        
        ptemp=pbcb->MemberOut;
        if(ptemp==pbcb->BuffStart)
                {
                ptemp=pbcb->BuffEnd;
                }

        pdest=(UBYTE *)ptemp;
        pdest=pdest-(pbcb->MemberSizeof);
        return((void *)pdest);
}
//得到缓冲器的取出成员的地址
void *        GetBufferOutAddr(STR_BufferCB *pbcb)
{
        return(pbcb->MemberOut);
}

使用时：
  1：先定义一个缓冲区，定义一个缓冲区控制块变量
  2：初始化缓冲器控制块
  3：可调用其他的对缓冲器的操作函数

例子：

typedef        struct
{
        UWORD        uw_v;
        ULONG        ul_v;
} str_type;

#define                BUF1_SIZE        5
STR_BufferCB        Buffer1CB;
str_type                Buffer1[BUF1_SIZE];

void        main(void)
{
        str_type        ul_1var;
        str_type        ul_2var;
        str_type        ul_3var;
        str_type        ul_4var;
        UWORD        uw_msg[20];
        void        *vp_1var;
        void        *vp_2var;
        void        *vp_3var;
        void        *vp_4var;
        void        *vp_5var;
        UWORD        uw_1var;
        UWORD        uw_2var;
        UWORD        uw_3var;

        InitBufferCB(&Buffer1CB,(void *)Buffer1,BUF1_SIZE,sizeof(Buffer1[0]));
        uw_msg[0]=BufferMemberPush(&Buffer1CB,(void *)&ul_1var);
        //uw_msg[1]=BufferMemberPush(&Buffer1CB,(void *)&ul_1var);
        //uw_msg[2]=BufferMemberPush(&Buffer1CB,(void *)&ul_1var);
        //uw_msg[3]=BufferMemberPush(&Buffer1CB,(void *)&ul_1var);
        //uw_msg[4]=BufferMemberPush(&Buffer1CB,(void *)&ul_1var);
        //uw_msg[5]=BufferMemberPush(&Buffer1CB,(void *)&ul_1var);
        uw_msg[6]=BufferMemberPushFront(&Buffer1CB,(void *)&ul_2var);
        //uw_msg[7]=BufferMemberPushFront(&Buffer1CB,(void *)&ul_2var);
        //uw_msg[8]=BufferMemberPushFront(&Buffer1CB,(void *)&ul_2var);
        //uw_msg[9]=BufferMemberPushFront(&Buffer1CB,(void *)&ul_2var);
        //uw_msg[10]=BufferMemberPushFront(&Buffer1CB,(void *)&ul_2var);
        //uw_msg[11]=BufferMemberPushFront(&Buffer1CB,(void *)&ul_2var);
        //uw_msg[12]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);
        //uw_msg[13]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);
        //uw_msg[14]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);
        //uw_msg[15]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);
        //uw_msg[16]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);
        //uw_msg[17]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);
        //uw_msg[18]=BufferMemberPop(&Buffer1CB,(void *)&ul_3var);

        vp_1var=GetBufferStartAddr(&Buffer1CB);
        vp_2var=GetBufferEndAddr(&Buffer1CB);
        vp_3var=GetBufferInAddr(&Buffer1CB);
        vp_4var=GetBufferInAddrFront(&Buffer1CB);
        vp_5var=GetBufferOutAddr(&Buffer1CB);
        uw_1var=GetBufferSize(&Buffer1CB);
        uw_2var=GetBufferSizeof(&Buffer1CB);
        uw_3var=GetBufferEntries(&Buffer1CB);

        for(;
                {
                NOP();
                }
}

有什么不足的地方，大家一起讨论讨论。