import

AppKit/fifo.c

@@ -0,0 +1,399 @@
+#include <fifo.h>
+#include <os_macros.h>
+#include <ctype.h>  // isspace
+#include <limits.h> // ULONG_MAX
+
+/* ------------------------------------------------------------------------------------------------------------------ */
+/*  */
+
+
+// 在尾部写入数据
+os_err_t fifo_put(fifo_t* self, uint8_t data){
+
+    os_size_t write_idx = self->write_idx;
+
+    os_size_t next_write_idx = write_idx + 1;
+    if(next_write_idx >= self->buffer_size){
+        next_write_idx = 0;
+    }
+
+    if(next_write_idx == self->read_idx){
+        return OS_ERR_FULL;
+    }
+
+    self->buffer[write_idx] = data;
+    self->write_idx = next_write_idx;
+
+    return OS_ERR_OK;
+}
+
+// 从头部获取数据
+os_err_t fifo_get(fifo_t* self, uint8_t* data){
+    os_size_t read_idx = self->read_idx;
+    if(read_idx==self->write_idx){
+        return OS_ERR_EMPTY;
+    }
+
+    if(data){
+        *data = self->buffer[read_idx];
+    }
+
+    os_size_t next_read_idx = read_idx + 1;
+    if(next_read_idx >= self->buffer_size){
+        next_read_idx = 0;
+    }
+    self->read_idx = next_read_idx;
+    return OS_ERR_OK;
+}
+
+// 批量写入数据
+os_size_t fifo_write(fifo_t* self, uint8_t* data, os_size_t size){
+    os_size_t i;
+    for(i=0; i<size; i++){
+        if(fifo_put(self, data[i])!=OS_ERR_OK){
+            break;
+        }
+    }
+    return i;
+}
+
+// 批量读取数据
+os_size_t fifo_read(fifo_t* self, uint8_t* buf, os_size_t size){
+    os_size_t i;
+    for(i=0; i<size; i++){
+        if(fifo_get(self, buf++)!=OS_ERR_OK){
+            break;
+        }
+    }
+    return i;
+}
+
+os_size_t fifo_write_fast(fifo_t* rb, const uint8_t * data, os_size_t len){
+    if (rb == NULL || data == NULL || len == 0) {
+        return 0;
+    }
+
+    /* 如果写入数据超过剩余空间，则只写入剩余空间部分（或者可以选择报错/覆盖，这里选择截断） */
+    os_size_t free_sp = fifo_space(rb);
+    if (len > free_sp) {
+        len = free_sp;
+    }
+
+    if (len == 0) {
+        // 没有空间了
+        return 0;
+    }
+
+    // 分段写入
+    // buf_size: 8
+    // 0, 1, 2, 3, 4, 5, 6, 7
+    //          r     w
+    //       w        r
+    os_size_t write_idx = rb->write_idx;
+    os_size_t read_idx = rb->read_idx;
+    os_size_t size = rb->buffer_size;
+
+    if(write_idx > read_idx){
+        os_size_t first_part = size - write_idx;
+        if(first_part >= len){
+            // 一次就可以拷贝完成
+            memcpy(&rb->buffer[write_idx], data, first_part);
+        }else{
+            // 分成两个部分
+            memcpy(&rb->buffer[write_idx], data, first_part);
+            os_size_t second_part = len - first_part;
+            memcpy(&rb->buffer, &data[first_part], second_part);
+        }
+    }else{
+        // 这里不会有 write_idx == read_idx 的情况，这种情况，free_sp=0
+        // 前面已经计算过 len 就是最多可以存下的字节数，因此这里直接拷贝
+        memcpy(&rb->buffer[write_idx], data, len);
+    }
+
+    rb->write_idx = (write_idx + len) % size;
+
+    return len;
+}
+
+os_size_t fifo_read_fast(fifo_t* rb, uint8_t * data, os_size_t len){
+    if (rb == NULL || data == NULL || len == 0) {
+        return 0;
+    }
+
+    /* 如果读取长度超过有效数据长度，则只读取有效部分 */
+    os_size_t data_sz = fifo_count(rb);
+    if (len > data_sz) {
+        len = data_sz;
+    }
+
+    if (len == 0) {
+        return 0;
+    }
+
+    os_size_t read_idx = rb->read_idx;
+    os_size_t write_idx = rb->write_idx;
+    os_size_t size = rb->buffer_size;
+
+    // 分段读取
+    // buf_size: 8
+    // 0, 1, 2, 3, 4, 5, 6, 7
+    //    r        w
+    //       w        r
+
+    if(write_idx > read_idx){
+        memcpy(&data, &rb->buffer[read_idx], len);
+    }else{
+        os_size_t first_part = size - read_idx;
+        if(first_part >= len){
+            // 一次就可以拷贝完成
+            memcpy(data, &rb->buffer[read_idx], first_part);
+        }else{
+            // 分成两个部分
+            memcpy(data, &rb->buffer[read_idx], first_part);
+            os_size_t second_part = len - first_part;
+            memcpy(&data[first_part], &rb->buffer, second_part);
+        }
+    }
+
+    rb->read_idx  = (read_idx + len) % size;
+
+    return len;
+}
+
+os_err_t fifo_peek_at(fifo_t* self, os_size_t offset, uint8_t * data){
+    os_size_t data_sz = fifo_count(self);
+    if(offset >= data_sz){
+        return OS_ERR_FULL;
+    }
+    if(data){
+        os_size_t index = (self->read_idx + offset) % self->buffer_size;
+        *data = self->buffer[index];
+    }
+    return OS_ERR_OK;
+}
+
+os_size_t fifo_peek_bulk(fifo_t* rb, os_size_t offset, uint8_t* data, os_size_t len){
+    if (rb == NULL || data == NULL || len == 0) {
+        return 0;
+    }
+
+    /* 如果读取长度超过有效数据长度，则只读取有效部分 */
+    os_size_t data_sz = fifo_count(rb);
+
+    if(offset >= data_sz){
+        return 0;
+    }
+
+    if (len > (data_sz - offset)) {
+        len = data_sz - offset;
+    }
+
+    if (len == 0) {
+        return 0;
+    }
+
+    os_size_t size = rb->buffer_size;
+    os_size_t read_idx = (rb->read_idx + offset) % size;
+    os_size_t write_idx = rb->write_idx;
+
+    // 分段读取
+    // buf_size: 8
+    // 0, 1, 2, 3, 4, 5, 6, 7
+    //    r        w
+    //       w        r
+
+    if(write_idx > read_idx){
+        memcpy(&data, &rb->buffer[read_idx], len);
+    }else{
+        os_size_t first_part = size - read_idx;
+        if(first_part >= len){
+            // 一次就可以拷贝完成
+            memcpy(data, &rb->buffer[read_idx], first_part);
+        }else{
+            // 分成两个部分
+            memcpy(data, &rb->buffer[read_idx], first_part);
+            os_size_t second_part = len - first_part;
+            memcpy(&data[first_part], &rb->buffer, second_part);
+        }
+    }
+
+    return len;
+}
+
+int fifo_memcmp(fifo_t *rb, os_size_t offset, const void *ptr, os_size_t len) {
+    os_size_t data_sz = fifo_count(rb);
+    OS_ASSERT(offset < data_sz);
+    OS_ASSERT(ptr);
+
+    if (len > (data_sz - offset)) {
+        // 如果请求比较的长度超过缓冲区现有数据量，可根据需求返回错误或只比较现有部分
+        // 这里假设调用者确保len <= fifo_count，或者我们只比较有效部分
+        len = data_sz - offset;
+    }
+
+    uint8_t rb_byte=0xff;
+    const uint8_t *external_ptr = (const uint8_t *)ptr;
+    for (os_size_t i = 0; i < len; i++) {
+        fifo_peek_at(rb, i + offset, &rb_byte);
+        if (rb_byte != external_ptr[i]) {
+            return (int)rb_byte - (int)external_ptr[i];
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * 在FIFO中查找特定模式
+ * @return: 找到则返回模式起始位置相对于head的偏移量，未找到返回-1
+ */
+os_size_t fifo_find(fifo_t *rb, os_size_t offset, const void *pattern, os_size_t pattern_len) {
+    if (!rb || !pattern || pattern_len == 0) {
+        return -1u;
+    }
+
+    os_size_t data_size = fifo_count(rb);
+    if(offset > data_size){
+        return -1u; // 开始查找位置错误了
+    }
+
+    if (pattern_len > (data_size - offset) ) {
+        return -1u; // 模式长度超过缓冲区数据量，不可能找到
+    }
+
+    // 遍历缓冲区中所有可能的起始位置
+    // 最大起始偏移为 count - pattern_len
+    os_size_t max_offset = data_size - offset - pattern_len;
+
+    for (os_size_t i = 0; i <= max_offset; i++) {
+        // 构造一个临时的“视图”或使用辅助函数比较从offset开始的pattern_len个字节
+        // 由于fifo_memcmp是从head开始比较，我们需要一种方法从任意offset开始比较
+
+        // 方法：逐字节比较
+        os_bool_t match = OS_TRUE;
+        const uint8_t *pat = (const uint8_t *)pattern;
+
+        for (os_size_t j = 0; j < pattern_len; j++) {
+            uint8_t rb_byte;
+            if (fifo_peek_at(rb, i + offset + j, &rb_byte)!=OS_ERR_OK) {
+                match = OS_FALSE;
+                break;
+            }
+            if (rb_byte != pat[j]) {
+                match = OS_FALSE;
+                break;
+            }
+        }
+
+        if (match) {
+            return i;
+        }
+    }
+
+    return -1u;
+}
+
+unsigned long fifo_strtoul(fifo_t* self, os_size_t* endptr /*从哪里开始转换*/, int base) {
+    os_size_t idx = endptr?(*endptr):0;
+    unsigned long acc = 0;
+    uint8_t c = 0xff;
+    unsigned long cutoff;
+    int neg = 0, any, cutlim;
+    ((void)neg);
+
+    fifo_peek_at(self, idx, &c);
+    // 1. 跳过前导空白字符
+    while (isspace((unsigned char)c)) {
+        idx++;
+    }
+
+    // 2. 处理可选的正负号 (strtoul 忽略负号，但会消耗它)
+    if (/* *s == '-'*/ fifo_offset_is(self, idx, '-')) {
+        neg = 1;
+        idx++;
+    } else if (/* *s == '+' */ fifo_offset_is(self, idx, '+')) {
+        idx++;
+    }
+
+    // 3. 确定基数
+    if (base == 0) {
+        if (/* *s == '0' */ fifo_offset_is(self, idx, '0')) {
+            if (/* *(s + 1) == 'x' || *(s + 1) == 'X' */
+                fifo_offset_is(self, idx+1, 'x')
+                    || fifo_offset_is(self, idx+1, 'X') )
+            {
+                base = 16;
+                idx += 2; // 跳过 0x
+            } else {
+                base = 8;
+                idx++; // 跳过 0
+            }
+        } else {
+            base = 10;
+        }
+    } else if (base == 16) {
+        if (/* *s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X') */
+            fifo_offset_is(self, idx, '0')
+                && (fifo_offset_is(self, idx+1, 'x') || fifo_offset_is(self, idx+1, 'X')) )
+        {
+            idx += 2;
+        }
+    }
+
+    // 4. 预计算溢出检查边界
+    cutoff = ULONG_MAX / (unsigned long)base;
+    cutlim = ULONG_MAX % (unsigned long)base;
+
+    // 5. 转换数字
+    any = 0; // 标记是否已读取到有效数字
+    for (; ; idx++) {
+//        c = (unsigned char)*s;
+        fifo_peek_at(self, idx, &c);
+
+        // 将字符转换为数值
+        if (c >= '0' && c <= '9') {
+            c -= '0';
+        } else if (c >= 'A' && c <= 'Z') {
+            c -= 'A' - 10;
+        } else if (c >= 'a' && c <= 'z') {
+            c -= 'a' - 10;
+        } else {
+            break; // 非数字字符，停止解析
+        }
+
+        // 检查字符是否在当前基数范围内
+        if (c >= base) {
+            break;
+        }
+
+        // 检查溢出
+        if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) {
+            any = -1;
+            break;
+        } else {
+            any = 1;
+            acc *= base;
+            acc += c;
+        }
+    }
+
+    // 6. 处理结果和错误
+    if (any < 0) {
+        acc = ULONG_MAX;
+//        errno = ERANGE;
+    } else if (!any) {
+        // 没有进行任何转换
+//        if (endptr) {
+//            *endptr = (char *)nptr;
+//        }
+        return 0;
+    }
+
+    // 设置 endptr 指向第一个未转换的字符
+    if (endptr) {
+        *endptr = idx;
+    }
+
+    return acc;
+}
+