ring.c

新一代基于事件的嵌入式操作系统dyos在三星的s3c44b0的arm芯片上的完整移植代码

        result = len;
    else
        result = ring->max_len - ring->len;
    if(ring->offset_read < result)
    {   //数据发生环绕
        ring->offset_read = ring->max_len - (result - ring->offset_read);
    }else
    {   //不发生环绕
        ring->offset_read -= result;
    }
    ring->len += result;
    return result;
}

//----取消若干数据-------------------------------------------------------------
//功能: 取消已经写入线性缓冲区的若干数据，就像从来没有写入一样。
//参数: ring,目标环形缓冲区指针.
//      len,退回的数据数量
//返回: 实际退回的数据量
//-----------------------------------------------------------------------------
uint32_t ring_skip_tail(struct ring_buf *ring,uint32_t size)
{
    uint32_t result;
    if(ring->len > size)
    {
        result = size;
        if(ring->offset_write < result)
        {   //数据发生环绕
            ring->offset_write = ring->max_len - (result - ring->offset_write);
        }else
        {   //不发生环绕
            ring->offset_read -= result;
        }
        ring->len -=result;
    }else
    {
        result = ring->len;
        ring_flush(ring);
    }
    return result;
}

//----查找字符------------------------------------------------------------------
//功能: 从ring当前读位置开始查找字符c的位置
//参数: ring,目标环形缓冲区指针
//      c,需查找的字符
//返回: c出现的位置,如果没有出现则返回 cn_limit_uint32
//------------------------------------------------------------------------------
uint32_t ring_search_ch(struct ring_buf *ring, char c)
{
    uint32_t    i;
    uint8_t *buf = ring->buf;
    if(ring->offset_read > ring->offset_write)
    {   //缓冲区有回绕
        for(i=ring->offset_read;i<ring->max_len;i++)
        {
            if(buf[i] == c)
                return (i - ring->offset_read);
        }
        for(i=0;i<ring->offset_write;i++)
            if(buf[i] == c)
                return (i - ring->offset_read + ring->max_len);
    }else
    {   //缓冲区没有回绕
        for(i = ring->offset_read; i < ring->offset_write; i++)
            if(buf[i] == c)
                return (i - ring->offset_read);
    }
    return cn_limit_uint32;
}

//----查找字符序列--------------------------------------------------------------
//功能: 从ring当前读位置开始查找字符序列的位置,字符序列不以0结束,而是指定长度
//参数: ring,目标环形缓冲区指针
//      string,需查找的字符序列
//      str_len,字符序列长度
//返回: string出现的位置相对offset_read的偏移量,如果没有出现返回 cn_limit_uint32
//备注: 这个功能可能比较常用,所以在编写时注意了速度优化,但却使代码量大增.
//------------------------------------------------------------------------------
uint32_t ring_search_str(struct ring_buf *ring, char *string,uint32_t str_len)
{
    uint32_t i,j;
    bool_t next;
    uint8_t *buf;
    uint32_t  end,start;

    if(ring->len < str_len)
        return cn_limit_uint32;
    buf = ring->buf;
    if(ring->offset_read <= ring->offset_write)
    {   //缓冲区没有回绕
        for(i=ring->offset_read;i <= ring->offset_write - str_len;i++)
        {
            next = false;
            for(j=0;j < str_len;j++)
            {
                if(buf[i+j] != string[j])
                    next = true;
            }
            if(next == false)
            {
                return (i - ring->offset_read);
                break;
            }
        }
    }else
    {   //缓冲区有回绕
        //先处理不环绕部分,不包括缓冲区首末结合部分
        for(i=ring->offset_read;i <= (ring->max_len - str_len);i++)
        {
            next = false;
            for(j=0;j < str_len;j++)
            {
                if(buf[i+j] != string[j])
                    next = true;    //如果发现不等,则表示要进行下一个循环
            }
            if(next == false)
            {   //表示上一个循环中已经发现匹配的串,
                return (i - ring->offset_read);
                break;
            }
        }
        //再处理缓冲区首末结合部分以及回绕部分
        if(ring->offset_write >= str_len)
        {   //缓冲区中回绕部分的长度超过查找长度,末端和首端分别查找
            //先查找缓冲区末端部分
            for(;i < ring->max_len;i++)
            {
                next = false;
                //string分成两部分,end个字符在缓冲区末端,start个字符在缓冲区首
                end = ring->max_len - i;
                start = str_len - end;
                for(j=0;j<end;j++)
                {   //先比较缓冲区末端部分
                    if(buf[i+j] != string[j])
                        next = true;
                }
                if(next == false)
                {   //缓冲区末端部分全部匹配,需要看首端是否也匹配
                    for(j=0;j<start;j++)
                        if(buf[j] != string[start+j])
                            next = true;
                }
                if(next == false)
                {   //表示上一个循环中已经发现匹配的串,
                    return (i - ring->offset_read);
                    break;
                }
            }
            //再查找首端部分
            for(i=0;i < (ring->offset_write - str_len);i++)
            {
                next = false;
                for(j=0;j < str_len;j++)
                {
                    if(buf[i+j] != string[j])
                        next = true;    //如果发现不等,则表示要进行下一个循环
                }
                if(next == false)
                {   //表示上一个循环中已经发现匹配的串,
                    return (i - ring->offset_read);
                    break;
                }
            }
        }else
        {   //缓冲区中回绕部分长度没有超过str_len,只需要查找末端即可.
            next = false;
            for(;i < (ring->offset_read + ring->len - str_len);i++)
            {
                uint32_t  end,start;
                next = false;
                //string分成两部分,end个字符在缓冲区末端,start个字符在缓冲区首
                end = ring->max_len - i;
                start = str_len - end;
                for(j=0;j<end;j++)
                {   //先比较缓冲区末端部分
                    if(buf[i+j] != string[j])
                        next = true;
                }
                if(next == false)
                {   //缓冲区末端部分全部匹配,需要看首端是否也匹配
                    for(j=0;j<start;j++)
                        if(buf[j] != string[start+j])
                            next = true;
                }
                if(next == false)
                {   //表示上一个循环中已经发现匹配的串,
                    return (i - ring->offset_read);
                    break;
                }
            }
        }
    }
    return cn_limit_uint32;
}