调整vlog，新增了一些模块的redme

README.en.md

@@ -13,7 +13,7 @@ It has the characteristics of **simplicity, universality, and efficiency**, with
 
 | module       | version  | usage                        | path                                  | describe                              |
 |:-------------|:---------|:-----------------------------|:--------------------------------------|:--------------------------------------|
-| overall      | 00.01.00 | [link](README.md)            | ./                                    | Overall
+| overall      | 00.01.01 | [link](README.md)            | ./                                    | Overall
 | init         | 01.00.00 | [link](/doc/init.md)         | ./source/00_application               | Initialize export module
 | console      | 01.00.00 | [link](/doc/console.md)      | ./source/00_application/console       | Console command input, combined with the 'command' module, parsing commands entered in the console
 | arg          | 01.00.00 | [link](/doc/arg.md)          | ./source/01_general                   | Indefinite parameters, obtain the number of indefinite parameters and specified parameters
@@ -28,7 +28,7 @@ It has the characteristics of **simplicity, universality, and efficiency**, with
 | sList        | 01.00.00 | [link](/doc/sList.md)        | ./source/01_general                   | Universal single-link list controller
 | tool         | 01.00.00 | [link](/doc/tool.md)         | ./source/01_general                   | General tools code
 | valloc       | 01.00.00 | [link](/doc/valloc.md)       | ./source/01_general                   | Dynamic memory usage testing tool
-| vlog         | 01.00.00 | [link](/doc/vlog.md)         | ./source/01_general                   | Log output module
+| vlog         | 01.01.00 | [link](/doc/vlog.md)         | ./source/01_general                   | Log output module
 | vctype       | 01.00.00 | [link](/doc/vctype.md)       | ./source/02_vstd                      | Similar to the C standard library ctype
 | vmath        | 01.00.00 | [link](/doc/vmath.md)        | ./source/02_vstd                      | Similar to the C standard library math
 | vmem         | 01.00.00 | [link](/doc/vmem.md)         | ./source/02_vstd                      | Simple implementation of memory pool

README.md

@@ -13,7 +13,7 @@ varch（we-architecture，意为我们的框架库）是嵌入式C语言常用
 
 | module       | version  | usage                        | path                                  | describe                              |
 |:-------------|:---------|:-----------------------------|:--------------------------------------|:--------------------------------------|
-| overall      | 00.01.00 | [link](README.md)            | ./                                    | Overall
+| overall      | 00.01.01 | [link](README.md)            | ./                                    | Overall
 | init         | 01.00.00 | [link](/doc/init.md)         | ./source/00_application               | Initialize export module
 | console      | 01.00.00 | [link](/doc/console.md)      | ./source/00_application/console       | Console command input, combined with the 'command' module, parsing commands entered in the console
 | arg          | 01.00.00 | [link](/doc/arg.md)          | ./source/01_general                   | Indefinite parameters, obtain the number of indefinite parameters and specified parameters
@@ -28,7 +28,7 @@ varch（we-architecture，意为我们的框架库）是嵌入式C语言常用
 | sList        | 01.00.00 | [link](/doc/sList.md)        | ./source/01_general                   | Universal single-link list controller
 | tool         | 01.00.00 | [link](/doc/tool.md)         | ./source/01_general                   | General tools code
 | valloc       | 01.00.00 | [link](/doc/valloc.md)       | ./source/01_general                   | Dynamic memory usage testing tool
-| vlog         | 01.00.00 | [link](/doc/vlog.md)         | ./source/01_general                   | Log output module
+| vlog         | 01.01.00 | [link](/doc/vlog.md)         | ./source/01_general                   | Log output module
 | vctype       | 01.00.00 | [link](/doc/vctype.md)       | ./source/02_vstd                      | Similar to the C standard library ctype
 | vmath        | 01.00.00 | [link](/doc/vmath.md)        | ./source/02_vstd                      | Similar to the C standard library math
 | vmem         | 01.00.00 | [link](/doc/vmem.md)         | ./source/02_vstd                      | Simple implementation of memory pool

doc/cQueue.md

@@ -0,0 +1,180 @@
+## 介绍  
+
+队列是一种先进先出(First In First Out,FIFO)的特殊数据结构，一般情况下它只有一个出口一个入口，从队尾进入从队头出，入队push，出队pop。 
+
+cQueue为一个队列控制体，自身本不是容器，和varch的queue有区别，但是使用上却很类似。     
+
+## 接口  
+
+### 定义队列类型
+
+因为cQueue本身并不是数据容器，所以需要对其存储的数据类型定义一个新的数据结构，如下例子
+
+```c
+typedef struct 
+{
+    cQueue queue;               // 第一个成员，默认为这个，无需改动
+    int data[10];               // 第二个成员，定义实际存储的数据数组，数组类型为任意类型，数组名都为 data ， 容量根据实际所需
+} intQueueType;                 // 定义一个新的数据结构体类型
+intQueueType intQueue;          // 定义一个新的结构体变量
+```
+
+### 初始化队列
+
+```c
+#define cQueue_init(qObject)
+```
+
+宏定义方法，能适配各种数据类型
+ 
+```c
+void test_int(void)
+{
+    typedef struct 
+    {
+        cQueue queue;
+        int data[10];
+    } intQueueType;
+    intQueueType intQueue;
+
+    cQueue_init(intQueue);
+}
+```
+
+### 队列空队和满队  
+
+```c
+#define cQueue_empty(qObject)
+#define cQueue_full(qObject)
+```
+
+这两个方法实际就是queue的`size`的大小关系，等于0为空，等于容量则满。  
+
+### 队列数据入队和出队    
+
+```c
+#define cQueue_push(qObject, d)
+#define cQueue_pop(qObject, d)
+```
+
+这两个方法分别将数据d入队，和从队列出队数据到d  
+ 
+```c
+void test_int(void)
+{
+    typedef struct 
+    {
+        cQueue queue;
+        int data[10];
+    } intQueueType;
+    intQueueType intQueue;
+
+    cQueue_init(intQueue);
+
+    for (int i = 0; i < intQueue.queue.cap; i++)
+    {
+        cQueue_push(intQueue, i);
+    }
+
+    while (intQueue.queue.size > 0)
+    {
+        int data;
+        cQueue_pop(intQueue, data);
+        printf("cQueue_pop %d\r\n", data);
+    }
+}
+```
+结果： 
+```
+cQueue_pop 0
+cQueue_pop 1
+cQueue_pop 2
+cQueue_pop 3
+cQueue_pop 4
+cQueue_pop 5
+cQueue_pop 6
+cQueue_pop 7
+cQueue_pop 8
+cQueue_pop 9
+```
+
+### 队列数据访问  
+
+```c
+#define cQueue_at(qObject, i)
+```
+
+随机访问队列中的数据。  
+
+```c
+void test_int(void)
+{
+    typedef struct 
+    {
+        cQueue queue;
+        int data[10];
+    } intQueueType;
+    intQueueType intQueue;
+
+    cQueue_init(intQueue);
+
+    for (int i = 0; i < intQueue.queue.cap; i++)
+    {
+        cQueue_push(intQueue, i);
+    }
+
+    printf("cQueue[5] = %d\r\n", cQueue_at(intQueue, 5));
+}
+```
+结果： 
+```
+cQueue[5] = 5
+```
+
+## 特殊数据结构体例子  
+
+```c
+void test_struct(void)
+{
+    typedef struct 
+    {
+        char *name;
+        int age;
+    } Stu;
+    typedef struct 
+    {
+        cQueue queue;
+        Stu data[10];
+    } StuQueueType;
+    StuQueueType StuQueue;
+
+    Stu s = {"Zhang", 18};
+
+    cQueue_init(StuQueue);
+
+    for (int i = 0; i < StuQueue.queue.cap; i++)
+    {
+        s.age = 18 + i;
+        cQueue_push(StuQueue, s);
+    }
+
+    while (StuQueue.queue.size > 0)
+    {
+        cQueue_pop(StuQueue, s);
+        printf("cQueue_pop name: %s age %d\r\n", s.name, s.age);
+    }
+}
+```
+结果： 
+```
+cQueue_pop name: Zhang age 18
+cQueue_pop name: Zhang age 19
+cQueue_pop name: Zhang age 20
+cQueue_pop name: Zhang age 21
+cQueue_pop name: Zhang age 22
+cQueue_pop name: Zhang age 23
+cQueue_pop name: Zhang age 24
+cQueue_pop name: Zhang age 25
+cQueue_pop name: Zhang age 26
+cQueue_pop name: Zhang age 27
+```

doc/dList.md

@@ -0,0 +1,558 @@
+## 介绍  
+
+链表是一种数据结构，其中的数据元素逻辑上连续，但在物理上可以分散存储。链表能够通过指针将多个相同类型的数据块链接成一个完整的序列，在数据结构的实现中具有重要作用。   
+
+dList模块为通用的双向链表模块，其与sList模块非常相似，区别在于指针域由单向链表的一个指向改为两个指向（一个指向下一个，一个指向上一个），如此在存储结构上也有差异，sList为单向开环结构，dList为双向闭环结构（首尾相连，形成环形）。  
+在API方面，使用是和sList基本一致的（底层实现不太一样），其余性能和优缺点对比在下文展示。     
+
+## 接口  
+
+### 创建dList
+
+```c
+dList *dList_create(void);
+```
+
+在dList中，dList既是一个链表也是一个结点（因为结点也就是长度为1的链表）。所以此方法是创建一个为空的并且长度为1的链表（也就是创建一个空结点）。
+
+### 删除dList
+
+```c
+void dList_delete(dList *list);
+```
+
+此方法会删除该链表（包含其所有的结点）。
+
+### 设置和获取dList结点内容
+
+```c
+int dList_set(dList *list, void* data, int size);
+int dList_get(dList *list, void* data, int size);
+```
+
+当一个结点被创建好之后，数据域是不具备内容的，需要通过`dList_set`方法设置其数据域内容，并且可以使用`dList_get`方法来获取结点数据域内容。  
+`dList_set`方法会将原来的数据覆盖掉，同时也是指定`size`为 **0** 来删除dList结点数据内容。  
+
+```c
+static void test_set(void)
+{
+    dList *list = NULL;
+    int dataInt = 3;
+    char *dataString = "Hello dList";
+
+    list = dList_create();
+    if (!list)
+    {
+        printf("dList_create Fail!\r\n");
+        return;
+    }
+
+    printf("dList_create Success!\r\n");
+
+    dList_set(list, &dataInt, sizeof(dataInt));
+    printf("list->data %d\r\n", dList_ref(list, int));
+
+    dList_set(list, dataString, strlen(dataString) + 1);
+    printf("list->data %s\r\n", ((char *)(list->data)));
+
+    dList_delete(list);
+}
+```
+结果： 
+```
+dList_create Success!
+list->data 3
+list->data Hello dList
+```
+
+示例中的`dList_ref`为数据引用，具体用法在下文
+
+### dList插入数据
+
+```c
+dList *dList_insert(dList **listRef, int index, void *data, int size);
+```
+
+插入数据方法使用起来会更加简便，省去创建结点和设置数据的环节（即使是链表表头也可以省略创建，而由此方法内部完成），可以灵活的将指定数据插入到指定的位置上。  
+
+```c
+static void test_insert(void)
+{
+    dList *list = NULL;
+
+    for (int i = 0; i < 2; i++)
+    {
+        if (!dList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+    }
+
+    int i = 100;
+    if (!dList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+    printf("------------\r\n");
+
+    dList_forEachReverse(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+data 0
+data 1
+data 100
+------------
+data 100
+data 1
+data 0
+```
+
+示例中的`dList_forEachForward`和`dList_forEachReverse`为遍历方法，具体用法在下文。 
+对于传入dList引用为空时，会在首次创建结点并生成表头，传入`index`为负数表示插入到尾部。可以使用默认定义好的`dList_front`和`dList_back`宏定义来代表头部和尾部。   
+
+### dList擦除数据
+
+```c
+int dList_erase(dList **listRef, int index, dList **outPrev);
+```
+
+此方法对照`dList_insert`方法，擦除指定位置数据（会将该结点从链表中删除），同时为了更灵活使用，也支持获取被擦除的上一个结点（可以更便利高效得完成连续擦除）。  
+
+```c
+static void test_erase(void)
+{
+    dList *list = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!dList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+    }
+
+    dList_erase(&list, 0, NULL);
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+data 1
+data 2
+data 3
+data 4
+```
+
+对照前面插入的例子，擦除表头。 
+
+### dList推入和弹出
+
+```c
+int dList_pushFront(dList **listRef, void *data, int size);
+int dList_pushBack(dList **listRef, void *data, int size);
+int dList_popFront(dList **listRef);
+int dList_popBack(dList **listRef);
+```
+
+分别就是头插、尾插、头删、尾删方法，其实就是在`dList_insert`和`dList_erase`方法基础上针对常用场景进行封装，使用更简便。    
+
+```c
+static void test_pop(void)
+{
+    dList *list = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!dList_pushFront(&list, &i, sizeof(i))) goto FAIL;
+    }
+    for (int i = 0; i < 5; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    dList_popBack(&list);
+    dList_popBack(&list);
+    dList_popFront(&list);
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+data 3
+data 2
+data 1
+data 0
+data 0
+data 1
+data 2
+```
+
+### dList追加
+
+```c
+int dList_append(dList *list, dList **append);
+```
+
+此方法可以将两个链表拼接成一个链表，`append`链表在拼接成功后会失效。  
+
+**注意** `append`需为表头，虽然即使不是表头也能拼接成功，但是其还属于原来的链表中，在操作时会出现一些意外。  
+
+```c
+static void test_append(void)
+{
+    dList *list = NULL, *ap = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+        if (!dList_pushBack(&ap, &i, sizeof(i))) goto FAIL;
+    }
+
+    if (!dList_append(list, &ap)) goto FAIL;
+
+    printPoint(ap);
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+    dList_delete(ap);
+}
+```
+结果： 
+```
+ap: 00000000
+data 0
+data 1
+data 2
+data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+data 0
+data 1
+data 2
+data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+```
+
+### dList链接结点
+
+```c
+dList *dList_attach(dList **listRef, int index, dList *attach);
+```
+
+这个方法是将一个结点(或者一个链表)链接到现有的一个链表当中，可以通过index来指定具体链接到哪个位置，这个方法很灵活，直接操作链表结构，**一般情况使用不上此方法**，而是使用此方法所封装的`dList_insert`等方法。此方法可以搭配其他方法灵活二次封装成其他方法。 
+
+```c
+static void test_attach(void)
+{
+    dList *list = NULL, *a = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+    for (int i = 0; i < 3; i++)
+    {
+        if (!dList_pushBack(&a, &i, sizeof(i))) goto FAIL;
+    }
+
+    dList_attach(&list, -1, a);
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+data 0
+data 1
+data 2
+data 3
+data 4
+data 0
+data 1
+data 2
+```
+
+### dList断链结点
+
+```c
+dList *dList_detach(dList **listRef, int begin, int end, dList **outPrev);
+```
+
+这个方法与`dList_attach`方法为对照方法，可以从链表中断链出来若干个结点（子链表），可以通过index来指定具体断链哪个位置和count指定个数，这个方法很灵活，直接操作链表结构，**一般情况使用不上此方法**，而是使用此方法所封装的`dList_erase`等方法。此方法可以搭配其他方法灵活二次封装成其他方法。 
+
+```c
+static void test_detach(void)
+{
+    dList *list = NULL, *node = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!dList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+    }
+
+#if 1
+    node = dList_detach(&list, 0, 3, NULL);
+    if (!node)
+    {
+        printf("dList_detach fail\r\n");
+    }
+#endif 
+
+    dList_forEachForward(node, n)
+    {
+        printf("node data %d\r\n", dList_ref(n, int));
+    }
+
+    dList_delete(node);
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+node data 0
+node data 1
+node data 2
+node data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+```
+
+### dList复制
+
+```c
+dList *dList_copy(dList *list, int begin, int end);
+```
+
+这个方法是会根据源链表的指定区间进行深拷贝一份新的链表。 
+
+```c
+static void test_copy(void)
+{
+    dList *list = NULL, *copy = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    copy = dList_copy(list, -5, -1);
+    if (!copy)
+    {
+        printf("dList_copy fail\r\n");
+    }
+
+    dList_forEachForward(copy, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+    dList_delete(copy);
+}
+```
+结果： 
+```
+data 5
+data 6
+data 7
+data 8
+data 9
+```
+
+### dList区间翻转
+
+```c
+int dList_reverse(dList *list, int begin, int end);
+```
+
+这个方法是会根据源链表的指定区间进行翻转。 
+
+```c
+static void test_reverse(void)
+{
+    dList *list = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    if (!dList_reverse(list, 1, 5))
+    {
+        printf("dList_reverse fail\r\n");
+    }
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+} 
+```
+结果： 
+```
+data 0
+data 5
+data 2
+data 3
+data 4
+data 1
+data 6
+data 7
+data 8
+data 9
+```
+
+### dList获取指定结点
+
+```c
+dList *dList_to(dList *list, int index);
+```
+
+这个方法可以根据表头当前位置获取偏移指定位置的结点，传入负数可以从末端往回找。   
+
+```c
+static void test_to(void)
+{
+    dList *list = NULL, *node;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    node = dList_to(list, -6);
+    if (!node)
+    {
+        printf("dList_to fail\r\n");
+        goto FAIL;
+    }
+
+    printf("dList_to data %d\r\n", dList_ref(node, int));
+
+    dList_forEachForward(list, n)
+    {
+        printf("data %d\r\n", dList_ref(n, int));
+    }
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+dList_to data 4
+data 0
+data 1
+data 2
+data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+```
+
+### dList大小
+
+```c
+int dList_size(dList *list);
+```
+
+这个方法获取链表的数据个数。   
+
+```c
+static void test_size(void)
+{
+    dList *list = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    printf("size %d\r\n", dList_size(list));
+    printf("size %d\r\n", dList_size(dList_to(list, 3)));
+
+FAIL:
+    dList_delete(list);
+}
+```
+结果： 
+```
+size 10
+size 7
+```
+
+### dList遍历
+
+```c
+#define dList_forEach(list, node)           // 从前往后遍历
+#define dList_forEachForward(list, node)    // 从前往后遍历
+#define dList_forEachReverse(list, node)    // 从后往前遍历
+```
+
+这个方法为遍历链表的方法，具体例子可以参考上文其他使用例子。     
+
+### dList结点数据引用
+
+```c
+#define dList_ref(node, type)
+```
+
+这个方法类似C++的引用，实则是操作指针(只是将其隐藏起来)，读写更方便，但要注意的是数据操作别越界，比如本来该结点存储的是`char`型数据（分配空间也就只分配1个字节大小），如果当作`int`型使用那就越界了。具体例子可以参考上文其他使用例子。     
+

doc/sList.md

@@ -0,0 +1,533 @@
+## 介绍  
+
+链表是一种数据结构，其中的数据元素逻辑上连续，但在物理上可以分散存储。链表能够通过指针将多个相同类型的数据块链接成一个完整的序列，在数据结构的实现中具有重要作用。   
+
+sList模块为通用的单向链表模块，它通过一系列相互链接的节点来存储线性的数据集合。每个节点包含数据域和指向下一个节点的指针域。     
+
+## 接口  
+
+### 创建sList
+
+```c
+sList *sList_create(void);
+```
+
+在sList中，sList既是一个链表也是一个结点（因为结点也就是长度为1的链表）。所以此方法是创建一个为空的并且长度为1的链表（也就是创建一个空结点）。
+
+### 删除sList
+
+```c
+void sList_delete(sList *list);
+```
+
+此方法会删除该链表（包含其所有的结点）。
+
+### 设置和获取sList结点内容
+
+```c
+int sList_set(sList *list, void* data, int size);
+int sList_get(sList *list, void* data, int size);
+```
+
+当一个结点被创建好之后，数据域是不具备内容的，需要通过`sList_set`方法设置其数据域内容，并且可以使用`sList_get`方法来获取结点数据域内容。  
+`sList_set`方法会将原来的数据覆盖掉，同时也是指定`size`为 **0** 来删除sList结点数据内容。  
+
+```c
+static void test_set(void)
+{
+    sList *list = NULL;
+    int dataInt = 3;
+    char *dataString = "Hello sList";
+    char outBuffer[32];
+
+    list = sList_create();
+    if (!list)
+    {
+        printf("sList_create Fail!\r\n");
+        return;
+    }
+
+    printf("sList_create Success!\r\n");
+
+    sList_set(list, &dataInt, sizeof(dataInt));
+    printf("list->data %d\r\n", sList_ref(list, int));
+
+    sList_set(list, dataString, strlen(dataString) + 1);
+    printf("list->data %s\r\n", ((char *)(list->data)));
+
+    sList_get(list, outBuffer, sizeof(outBuffer));
+    printf("get data %s\r\n", outBuffer);
+
+    sList_delete(list);
+}
+```
+结果： 
+```
+sList_create Success!
+list->data 3
+list->data Hello sList
+get data Hello sList
+```
+
+示例中的`sList_ref`为数据引用，具体用法在下文
+
+### sList插入数据
+
+```c
+sList *sList_insert(sList **listRef, int index, void *data, int size);
+```
+
+插入数据方法使用起来会更加简便，省去创建结点和设置数据的环节（即使是链表表头也可以省略创建，而由此方法内部完成），可以灵活的将指定数据插入到指定的位置上。  
+
+```c
+static void test_insert(void)
+{
+    sList *list = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!sList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+    }
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+data 0
+data 1
+data 2
+data 3
+data 4
+```
+
+示例中的`sList_forEach`为遍历方法，具体用法在下文。 
+对于传入sList引用为空时，会在首次创建结点并生成表头，传入`index`为负数表示插入到尾部。可以使用默认定义好的`sList_front`和`sList_back`宏定义来代表头部和尾部。   
+
+### sList擦除数据
+
+```c
+int sList_erase(sList **listRef, int index, sList **outPrev);
+```
+
+此方法对照`sList_insert`方法，擦除指定位置数据（会将该结点从链表中删除），同时为了更灵活使用，也支持获取被擦除的上一个结点（可以更便利高效得完成连续擦除）。  
+
+```c
+static void test_erase(void)
+{
+    sList *list = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!sList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+    }
+
+    sList_erase(&list, 0, NULL);
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+data 1
+data 2
+data 3
+data 4
+```
+
+对照前面插入的例子，擦除表头。 
+
+### sList推入和弹出
+
+```c
+int sList_pushFront(sList **listRef, void *data, int size);
+int sList_pushBack(sList **listRef, void *data, int size);
+int sList_popFront(sList **listRef);
+int sList_popBack(sList **listRef);
+```
+
+分别就是头插、尾插、头删、尾删方法，其实就是在`sList_insert`和`sList_erase`方法基础上针对常用场景进行封装，使用更简便。    
+
+```c
+static void test_pop(void)
+{
+    sList *list = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!sList_pushFront(&list, &i, sizeof(i))) goto FAIL;
+    }
+    for (int i = 0; i < 5; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    sList_popBack(&list);
+    sList_popBack(&list);
+    sList_popFront(&list);
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+data 3
+data 2
+data 1
+data 0
+data 0
+data 1
+data 2
+```
+
+### sList追加
+
+```c
+int sList_append(sList *list, sList **append);
+```
+
+此方法可以将两个链表拼接成一个链表，`append`链表在拼接成功后会失效。  
+
+**注意** `append`需为表头，虽然即使不是表头也能拼接成功，但是其还属于原来的链表中，在操作时会出现一些意外。  
+
+```c
+static void test_append(void)
+{
+    sList *list = NULL, *ap = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+        if (!sList_pushBack(&ap, &i, sizeof(i))) goto FAIL;
+    }
+
+    if (!sList_append(list, &ap)) goto FAIL;
+
+    printPoint(ap);
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+    sList_delete(ap);
+}
+```
+结果： 
+```
+data 0
+data 1
+data 2
+data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+data 0
+data 1
+data 2
+data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+```
+
+### sList链接结点
+
+```c
+sList *sList_attach(sList **listRef, int index, sList *attach);
+```
+
+这个方法是将一个结点(或者一个链表)链接到现有的一个链表当中，可以通过index来指定具体链接到哪个位置，这个方法很灵活，直接操作链表结构，**一般情况使用不上此方法**，而是使用此方法所封装的`sList_insert`等方法。此方法可以搭配其他方法灵活二次封装成其他方法。 
+
+```c
+static void test_attach(void)
+{
+    sList *list = NULL, *a = NULL;
+
+    for (int i = 0; i < 5; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+    for (int i = 0; i < 3; i++)
+    {
+        if (!sList_pushBack(&a, &i, sizeof(i))) goto FAIL;
+    }
+
+    sList_attach(&list, -1, a);
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+data 0
+data 1
+data 2
+data 3
+data 4
+data 0
+data 1
+data 2
+```
+
+### sList断链结点
+
+```c
+sList *sList_detach(sList **listRef, int index, int count, sList **outPrev);
+```
+
+这个方法与`sList_attach`方法为对照方法，可以从链表中断链出来若干个结点（子链表），可以通过index来指定具体断链哪个位置和count指定个数，这个方法很灵活，直接操作链表结构，**一般情况使用不上此方法**，而是使用此方法所封装的`sList_erase`等方法。此方法可以搭配其他方法灵活二次封装成其他方法。 
+
+```c
+static void test_detach(void)
+{
+    sList *list = NULL, *node;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!sList_insert(&list, -1, &i, sizeof(i))) goto FAIL;
+    }
+
+    node = sList_detach(&list, 3, -1, NULL);
+    if (!node)
+    {
+        printf("sList_detach fail\r\n");
+    }
+
+    sList_forEach(node, n)
+    {
+        printf("node data %d\r\n", sList_ref(n, int));
+    }
+
+    sList_delete(node);
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+node data 3
+node data 4
+node data 5
+node data 6
+node data 7
+node data 8
+node data 9
+data 0
+data 1
+data 2
+```
+
+### sList复制
+
+```c
+sList *sList_copy(sList *list, int begin, int end);
+```
+
+这个方法是会根据源链表的指定区间进行深拷贝一份新的链表。 
+
+```c
+static void test_copy(void)
+{
+    sList *list = NULL, *copy = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    copy = sList_copy(list, 2, -1);
+    if (!copy)
+    {
+        printf("sList_copy fail\r\n");
+    }
+
+    sList_forEach(copy, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+    sList_delete(copy);
+}
+```
+结果： 
+```
+data 2
+data 3
+data 4
+data 5
+data 6
+data 7
+data 8
+data 9
+```
+
+### sList区间翻转
+
+```c
+int sList_reverse(sList *list, int begin, int end);
+```
+
+这个方法是会根据源链表的指定区间进行翻转。 
+
+```c
+static void test_reverse(void)
+{
+    sList *list = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    if (!sList_reverse(list, sList_front, sList_back))
+    {
+        printf("sList_reverse fail\r\n");
+    }
+
+    sList_forEach(list, n)
+    {
+        printf("data %d\r\n", sList_ref(n, int));
+    }
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+data 9
+data 8
+data 7
+data 6
+data 5
+data 4
+data 3
+data 2
+data 1
+data 0
+```
+
+### sList获取指定结点
+
+```c
+sList *sList_to(sList *list, int index);
+```
+
+这个方法可以根据表头当前位置获取偏移指定位置的结点。   
+
+```c
+static void test_to(void)
+{
+    sList *list = NULL, *node;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    node = sList_to(list, 6);
+    if (!node)
+    {
+        printf("sList_to fail\r\n");
+        goto FAIL;
+    }
+
+    printf("data %d\r\n", sList_ref(node, int));
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+data 6
+```
+
+### sList大小
+
+```c
+int sList_size(sList *list);
+```
+
+这个方法获取链表的数据个数。   
+
+```c
+static void test_size(void)
+{
+    sList *list = NULL;
+
+    for (int i = 0; i < 10; i++)
+    {
+        if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
+    }
+
+    printf("size %d\r\n", sList_size(list));
+    printf("size %d\r\n", sList_size(sList_to(list, 3)));
+
+FAIL:
+    sList_delete(list);
+}
+```
+结果： 
+```
+size 10
+size 7
+```
+
+### sList遍历
+
+```c
+#define sList_forEach(list, node)
+```
+
+这个方法为遍历链表的方法，具体例子可以参考上文其他使用例子。     
+
+### sList结点数据引用
+
+```c
+#define sList_ref(node, type)
+```
+
+这个方法类似C++的引用，实则是操作指针(只是将其隐藏起来)，读写更方便，但要注意的是数据操作别越界，比如本来该结点存储的是`char`型数据（分配空间也就只分配1个字节大小），如果当作`int`型使用那就越界了。具体例子可以参考上文其他使用例子。     
+

doc/tool.md

@@ -0,0 +1,4 @@
+## 介绍  
+
+此工具模块包含了一些常用的代码工具，如常用的宏定义等。 
+

doc/valloc.md

@@ -0,0 +1,74 @@
+## 介绍  
+
+内存动态分配是指在程序运行过程中，根据程序的需要动态地分配内存空间，以便存储数据或创建对象。内存动态分配通常使用指针来实现，通过调用系统提供的内存分配函数（如malloc、calloc等）来申请内存空间，申请成功后，返回一个指向该内存空间的指针，进而在程序中使用该指针来访问分配的内存空间。
+
+内存动态分配的优点是可以动态地分配内存空间，避免浪费，提高内存使用效率。同时，动态分配的内存空间也可以随着程序的需求进行动态的释放，避免内存泄漏和出错。但是，使用内存动态分配也存在一些缺点，如容易出现内存泄漏、空间碎片等问题，需要程序员具有一定的技巧和注意事项才能正确、高效地使用内存动态分配。
+
+这里，介绍一种可以检查动态内存使用情况的小工具`valloc`，以便统计动态内存的使用情况，以及检查是否有空间碎片忘记释放。用其方法代替的内存分配方法，可以计算动态内存使用的情况。    
+
+## 接口  
+
+### 检查未释放内存
+
+```c
+void v_check_unfree(void);
+```
+
+### 获取已分配内存块计数
+
+```c
+int v_check_count(void);
+```
+
+### 获取已使用内存总大小
+
+```c
+int v_check_used(void);
+```
+
+## 使用  
+
+在使用上非常简单，如下几步。
+
+**1** 在需要统计的源文件中添加 `valloc.h` 头文件，添加到 `stdlib.h` 后面，不管哪一行只要在其后面，`valloc.h`中的内存函数（`malloc()等`）会将`stdlib.h`中的覆盖掉，而使用`valloc.h`的函数。  
+
+**2** 在需要输出的地方，调用 valloc 的API即可。  
+
+### 例子 
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "init.h"
+#include "valloc.h"
+
+static void test(void)
+{
+    void* p = NULL;
+    printf("malloc %p\r\n", malloc(0));
+    p = realloc(NULL, 100);
+    p = malloc(64);
+    p = malloc(50);
+    printf("realloc %p\r\n", realloc(NULL, 0));
+    printf("%d\r\n", *(int *)p);
+    free(p);
+
+    v_check_unfree();
+    printf("count = %d\r\n", v_check_count());
+    printf("used = %d\r\n", v_check_used());
+}
+init_export_app(test);
+```
+结果： 
+```
+malloc 007B5B50
+realloc 007B5C20
+8086040
+address: 007B5B50, size: 0, file: test/test_valloc.c, line: 10
+address: 007B5B88, size: 100, file: test/test_valloc.c, line: 11
+address: 007B5C20, size: 0, file: test/test_valloc.c, line: 14
+address: 007B5C68, size: 64, file: test/test_valloc.c, line: 12
+count = 4
+used = 164
+```

doc/vlog.md

@@ -0,0 +1,124 @@
+## 介绍  
+
+vlog是一个简单的日志输出模块，采用的是通道过滤模式，也就是提供了多个通道的日志输出，只有该通道使能了才会有日志输出。     
+
+## 接口  
+
+### vlog日志输出
+
+```c
+int vlog(vlogChnType channel, const char *format, ...);
+```
+
+channel提供了8个通道
+```
+#define VLOG_CHANNEL_0
+#define VLOG_CHANNEL_1
+#define VLOG_CHANNEL_2
+#define VLOG_CHANNEL_3
+#define VLOG_CHANNEL_4
+#define VLOG_CHANNEL_5
+#define VLOG_CHANNEL_6
+#define VLOG_CHANNEL_7
+```
+
+可以进行多通道的输出，通过 `|` 连接则进行多通道的输出。    
+默认是只打开了 `VLOG_CHANNEL_0`。
+
+```c
+static void test_vlog(void)
+{
+    vlog(VLOG_CHANNEL_0,   "[VLOG_CHANNEL_0] vlog!\r\n");
+    vlog(VLOG_CHANNEL_1,   "[VLOG_CHANNEL_1] vlog!\r\n");
+    vlog(VLOG_CHANNEL_2,   "[VLOG_CHANNEL_2] vlog!\r\n");
+}
+```
+结果： 
+```
+[VLOG_CHANNEL_0] vlog!
+```
+
+### vlog设置和获取通道过滤器
+
+```c
+void vlog_set_filter(vlogChnType mask);
+vlogChnType vlog_get_filter(void);
+```
+
+其分别可以设置和获取开放的通道过滤器。
+为了更简便，提供了如下宏定义方法可以打开和关闭指定通道。  
+
+```c
+#define VLOG_ENABALE(c) 
+#define VLOG_DISABALE(c)
+```
+
+```c
+static void test_channel(void)
+{
+    VLOG_DISABALE(VLOG_CHANNEL_0);
+    VLOG_ENABALE(VLOG_CHANNEL_1);
+
+    vlog(VLOG_CHANNEL_0,   "[VLOG_CHANNEL_0] vlog!\r\n");
+    vlog(VLOG_CHANNEL_1,   "[VLOG_CHANNEL_1] vlog!\r\n");
+    vlog(VLOG_CHANNEL_2,   "[VLOG_CHANNEL_2] vlog!\r\n");
+}
+```
+结果： 
+```
+[VLOG_CHANNEL_1] vlog!
+```
+
+### vlog控制台输出
+
+```c
+int vlog_set_console(vlogChnType channel, int console);
+```
+
+此方法是设置指定通道是否开启控制台输出，默认各个通道都已经打开控制台输出。
+
+### vlog离线保存 
+
+```c
+int vlog_set_offline(vlogChnType channel, const char *filename);
+```
+
+此方法可以开始离线保存和停止离线保存（传入空文件名）。  
+
+```c
+static void test_offline(void)
+{
+    vlog_set_offline(VLOG_CHANNEL_0, "./test/file/log.txt");
+
+    for (int i = 0; i < 10; i++)
+    {
+        vlog(VLOG_CHANNEL_0, "vlog %d!\r\n", i);
+    }
+
+    vlog_set_offline(VLOG_CHANNEL_0, NULL);
+}
+```
+结果： 
+[link](/test/file/log.txt)
+
+### vlog函数回调
+
+```c
+int vlog_set_func(vlogChnType channel, vlogFuncType func);
+```
+
+此方法设置vlog回调函数，提供了更大的灵活度。也就是函数vlog内容会输出到回调函数。  
+
+```c
+typedef void (*vlogFuncType)(char *buf, int len);
+```
+
+### vlog获取通道状态 
+
+```c
+vlogChnType vlog_get_console(void);
+vlogChnType vlog_get_offline(void);
+vlogChnType vlog_get_func(void);
+```
+
+其分别可以获取3种输出方向的各个通道状态掩码。 

makefile

@@ -42,9 +42,9 @@ SOURCES             += $(wildcard $(PARSER_PATH)/*.c)
 # SOURCES += $(TESTSPACE)/test_init.c
 # SOURCES += $(TESTSPACE)/test_kern.c
 # SOURCES += $(TESTSPACE)/test_valloc.c
-SOURCES += $(TESTSPACE)/test_arg.c
+# SOURCES += $(TESTSPACE)/test_arg.c
 # SOURCES += $(TESTSPACE)/test_vstd.c
-# SOURCES += $(TESTSPACE)/test_vlog.c
+SOURCES += $(TESTSPACE)/test_vlog.c
 # SOURCES += $(TESTSPACE)/test_ini.c
 # SOURCES += $(TESTSPACE)/test_txls.c
 # SOURCES += $(TESTSPACE)/test_xml.c

source/01_general/cQueue.h

@@ -89,7 +89,7 @@ int cQueue_index(cQueue *q, unsigned int index);
  *  \param[in] i: index starting from queue header
  *  \return Reference to queue data
  */
-#define cQueue_at(qObject, i)       ((qObject).data[cQueue_index(&((qObject).queue))])
+#define cQueue_at(qObject, i)       ((qObject).data[cQueue_index(&((qObject).queue), (i))])
 
 #if 0 /* cQueue demo */
 void test_int(void)

source/01_general/dList.h

@@ -200,6 +200,7 @@ int dList_get(dList *list, void* data, int size);
  * \param[in] list The head of the doubly linked list.
  * \param[in] node The iterator variable to represent each node in the list.
  */
+#define dList_forEach(list, node)           dList_forEachForward(list, node)
 #define dList_forEachForward(list, node) \
     for (dList* (node) = (list); (node); (node) = (((node)->next==(list))?NULL:(node)->next))
 

source/01_general/vlog.c

@@ -6,107 +6,214 @@
  *         \unit  vlog
  *        \brief  This is a simple log module for C language
  *       \author  Lamdonn
- *      \version  v1.0.0
+ *      \version  v1.1.0
  *      \license  GPL-2.0
  *    \copyright  Copyright (C) 2023 Lamdonn.
  ********************************************************************************************************/
 #include "vlog.h"
 #include <stdio.h>
 
-static char channel_table = VLOG_CHANNEL_0;                 /* Channel configuration, default only opens channel 0 */ 
+#define VLOG_CHANNEL_MAX                    (8)
-static char vlog_buffer[VLOG_BUFFER_SIZE];                  /* vlog output buffer */ 
-static vlog_func_t vlog_func = 0;                           /* Additional vlog callback function */ 
-static FILE *vlog_file = 0;                                 /* Offline recorded files */ 
 
-/**
+typedef struct 
- *  \brief output log information
- *  \param[in] channel: VLOG_CHANNEL_XXX, from 0 to 7
- *  \param[in] format: format string
- *  \param[in] ...: format parameters
- *  \return log string length
- */
-int vlog(char channel, const char *format, ...)
 {
-    int len = 0;
+    vlogChnType channel;                    /**< channel mask */
+    char console;                           /**< flag whether to output to the console */
+    vlogFuncType func;                      /**< flag whether to output to the callback function */
+    FILE *file;                             /**< flag whether to output to the offline file, protected ones cannot be modified directly */
+} vlogChnParaType;
+
+/* Channel configuration, default only opens channel 0 */
+static vlogChnType cmask = VLOG_CHANNEL_0;
+
+/* vlog output buffer */ 
+static char vlog_buffer[VLOG_BUFFER_SIZE];
+
+/* vlog channel parameters */
+static vlogChnParaType chn[VLOG_CHANNEL_MAX] = {
+/*   channel            console     func        file*/
+    {VLOG_CHANNEL_0,    1,          0,          0}, 
+    {VLOG_CHANNEL_1,    1,          0,          0}, 
+    {VLOG_CHANNEL_2,    1,          0,          0}, 
+    {VLOG_CHANNEL_3,    1,          0,          0}, 
+    {VLOG_CHANNEL_4,    1,          0,          0}, 
+    {VLOG_CHANNEL_5,    1,          0,          0}, 
+    {VLOG_CHANNEL_6,    1,          0,          0}, 
+    {VLOG_CHANNEL_7,    1,          0,          0}, 
+};
+
+int vlog(vlogChnType channel, const char *format, ...)
+{
+    int len = -1;
+    vlogChnType c;
     va_list args;
 
-    /* Check channel effectiveness */
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
-    if (channel & channel_table)
+    {
+        /* match channel */
+        if ((chn[c].channel & cmask) && (chn[c].channel & channel))
+        {
+            /* The current channel has a concrete output object */
+            if (chn[c].console || chn[c].file || chn[c].func)
+            {
+                /* If the output isn't already formatted, it needs to be. And format it only once. */
+                if (len == -1)
                 {
                     va_start(args, format);
-
                     len = vsnprintf(vlog_buffer, sizeof(vlog_buffer), format, args);
+                    va_end(args);
+                    if (len < 0) break;
+                }
                 
                 /* Output to default console */
-        printf(vlog_buffer);
+                if (chn[c].console) printf(vlog_buffer);
 
                 /* Output to offline file */
-        if (vlog_file) fwrite(vlog_buffer, sizeof(char), len, vlog_file);
+                if (chn[c].file) fwrite(vlog_buffer, sizeof(char), len, chn[c].file);
 
                 /* Output to callback function */
-        if (vlog_func) vlog_func(vlog_buffer, len);
+                if (chn[c].func) chn[c].func(vlog_buffer, len);
-
+            }
-        va_end(args);
+        }
     }
 
     return len;
 }
 
-/**
+void vlog_set_filter(vlogChnType mask)
- *  \brief set vlog channel configuration
- *  \param[in] channel: VLOG_CHANNEL_XXX, from 0 to 7, multiple channels can be selected through `|`
- *  \return none 
- */
-void vlog_set_channel(char channel)
 {
-    channel_table = channel;
+    cmask = mask;
 }
 
-/**
+vlogChnType vlog_get_filter(void)
- *  \brief get vlog channel configuration
- *  \return channel configuration 
- */
-char vlog_get_channel(void)
 {
-    return channel_table;
+    return cmask;
 }
 
-/**
+int vlog_set_console(vlogChnType channel, int console)
- *  \brief start vlog offline save, need to be used in pairs with vlog_stop_offline()
- *  \param[in] *filename: offline save file name
- *  \return 1 success or 0 fail 
- */
-int vlog_start_offline(const char *filename)
 {
+    int count = 0;
+    vlogChnType c;
+
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
+    {
+        /* match channel */
+        if (chn[c].channel & channel)
+        {
+            chn[c].console = (console ? 1: 0);
+
+            count++;
+        }
+    }
+
+    return count;
+}
+
+vlogChnType vlog_get_console(void)
+{
+    vlogChnType mask = 0;
+    vlogChnType c;
+
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
+    {
+        /* match channel */
+        if (chn[c].console)
+        {
+            mask |= chn[c].channel;
+        }
+    }
+
+    return mask;
+}
+
+int vlog_set_offline(vlogChnType channel, const char *filename)
+{
+    int count = 0;
+    vlogChnType c;
     FILE *file;
 
-    file = fopen(filename, "a+");
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
-    if (!file) return 0;
-
-    vlog_file = file;
-
-    return 1;
-}
-
-/**
- *  \brief stop vlog offline save, need to be used in pairs with vlog_start_offline()
- *  \return none
- */
-void vlog_stop_offline(void)
-{
-    if (vlog_file)
     {
-        fclose(vlog_file);
+        /* match channel */
-        vlog_file = 0;
+        if (chn[c].channel & channel)
+        {
+            /* If the name passed is empty, then the default is to turn off offline output */
+            if (!filename)
+            {
+                fclose(chn[c].file);
+                chn[c].file = 0;
+                continue;
             }
+
+            /* If a file has been defined for offline saving, it needs to be closed to open a new file */
+            if (chn[c].file)
+            {
+                fclose(chn[c].file);
+            }
+
+            /* Open an offline save file as an append */
+            file = fopen(filename, "a+");
+            if (!file) continue;
+
+            chn[c].file = file;
+
+            count++;
+        }
+    }
+
+    return count;
 }
 
-/**
+vlogChnType vlog_get_offline(void)
- *  \brief set additional vlog callback function
- *  \return none 
- */
-void vlog_set_func(vlog_func_t func)
 {
-    vlog_func = func;
+    vlogChnType mask = 0;
+    vlogChnType c;
+
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
+    {
+        /* match channel */
+        if (chn[c].file)
+        {
+            mask |= chn[c].channel;
+        }
+    }
+
+    return mask;
+}
+
+int vlog_set_func(vlogChnType channel, vlogFuncType func)
+{
+    int count = 0;
+    vlogChnType c;
+
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
+    {
+        /* match channel */
+        if (chn[c].channel & channel)
+        {
+            chn[c].func = func;
+
+            count++;
+        }
+    }
+
+    return count;
+}
+
+vlogChnType vlog_get_func(void)
+{
+    vlogChnType mask = 0;
+    vlogChnType c;
+
+    for (c = 0; c < VLOG_CHANNEL_MAX; c++)
+    {
+        /* match channel */
+        if (chn[c].func)
+        {
+            mask |= chn[c].channel;
+        }
+    }
+
+    return mask;
 }
 

source/01_general/vlog.h

@@ -6,7 +6,7 @@
  *         \unit  vlog
  *        \brief  This is a simple log module for C language
  *       \author  Lamdonn
- *      \version  v1.0.0
+ *      \version  v1.1.0
  *      \license  GPL-2.0
  *    \copyright  Copyright (C) 2023 Lamdonn.
  ********************************************************************************************************/
@@ -15,31 +15,100 @@
 
 #include <stdarg.h>
 
+/* Version infomation */
+
+#define VLOG_V_MAJOR                        1
+#define VLOG_V_MINOR                        1
+#define VLOG_V_PATCH                        0
+
+/* channel type define */
+
+typedef unsigned char                       vlogChnType;
+
+/* callback function define */
+
+typedef void                                (*vlogFuncType)(char *buf, int len);
+
 /* vlog buffer size */
+
 #define VLOG_BUFFER_SIZE                    (1024)
 
 /* vlog channel */
-#define VLOG_CHANNEL_0                  (0x01)
-#define VLOG_CHANNEL_1                  (0x02)
-#define VLOG_CHANNEL_2                  (0x04)
-#define VLOG_CHANNEL_3                  (0x08)
-#define VLOG_CHANNEL_4                  (0x10)
-#define VLOG_CHANNEL_5                  (0x20)
-#define VLOG_CHANNEL_6                  (0x40)
-#define VLOG_CHANNEL_7                  (0x80)
-#define VLOG_CHANNEL_ALL                (0xFF)
 
-#define VLOG_ENABALE(c)                 vlog_set_channel(vlog_get_channel() | (1 << (c)))
+#define VLOG_CHANNEL_0                      ((vlogChnType)(0x01))
-#define VLOG_DISABALE(c)                vlog_set_channel(vlog_get_channel() & ~(1 << (c)))
+#define VLOG_CHANNEL_1                      ((vlogChnType)(0x02))
+#define VLOG_CHANNEL_2                      ((vlogChnType)(0x04))
+#define VLOG_CHANNEL_3                      ((vlogChnType)(0x08))
+#define VLOG_CHANNEL_4                      ((vlogChnType)(0x10))
+#define VLOG_CHANNEL_5                      ((vlogChnType)(0x20))
+#define VLOG_CHANNEL_6                      ((vlogChnType)(0x40))
+#define VLOG_CHANNEL_7                      ((vlogChnType)(0x80))
+#define VLOG_CHANNEL_ALL                    ((vlogChnType)(0xFF))
 
-/* callback function define */
+/* Enable and disable a channel */
-typedef void (*vlog_func_t)(char *buf, int len);
 
-int vlog(char channel, const char *format, ...);
+#define VLOG_ENABALE(c)                     vlog_set_filter(vlog_get_filter() | (c))
-void vlog_set_channel(char channel);
+#define VLOG_DISABALE(c)                    vlog_set_filter(vlog_get_filter() & ~(c))
-char vlog_get_channel(void);
+
-int vlog_start_offline(const char *filename);
+/**
-void vlog_stop_offline(void);
+ *  \brief output log information
-void vlog_set_func(vlog_func_t func);
+ *  \param[in] channel: VLOG_CHANNEL_XXX, from 0 to 7
+ *  \param[in] format: format string
+ *  \param[in] ...: format parameters
+ *  \return log string length
+ */
+int vlog(vlogChnType channel, const char *format, ...);
+
+/**
+ *  \brief set vlog channel filter configuration
+ *  \param[in] mask: VLOG_CHANNEL_XXX, from 0 to 7, multiple channels can be selected through `|`
+ *  \return none 
+ */
+void vlog_set_filter(vlogChnType mask);
+
+/**
+ *  \brief get vlog channel filter configuration
+ *  \return channel filter configuration mask
+ */
+vlogChnType vlog_get_filter(void);
+
+/**
+ *  \brief turns vlog output to the console on or off
+ *  \param[in] channel: offline save file name
+ *  \param[in] console: 0 off or others on
+ *  \return 1 success or 0 fail 
+ */
+int vlog_set_console(vlogChnType channel, int console);
+
+/**
+ *  \brief gets the channel console open status
+ *  \return status mask
+ */
+vlogChnType vlog_get_console(void);
+
+/**
+ *  \brief start vlog offline save, need to be used in pairs with stop vlog offline save 
+ *  \param[in] filename: offline save file name, or NULL(0) stop vlog offline save
+ *  \return 1 success or 0 fail 
+ */
+int vlog_set_offline(vlogChnType channel, const char *filename);
+
+/**
+ *  \brief gets the channel offline open status
+ *  \return status mask
+ */
+vlogChnType vlog_get_offline(void);
+
+/**
+ *  \brief set additional vlog callback function
+ *  \return none 
+ */
+int vlog_set_func(vlogChnType channel, vlogFuncType func);
+
+/**
+ *  \brief gets the channel callback function open status
+ *  \return status mask
+ */
+vlogChnType vlog_get_func(void);
 
 #endif 

test/file/log.txt

@@ -0,0 +1,10 @@
+vlog 0!
+vlog 1!
+vlog 2!
+vlog 3!
+vlog 4!
+vlog 5!
+vlog 6!
+vlog 7!
+vlog 8!
+vlog 9!

test/test_cQueue.c

@@ -22,6 +22,8 @@ void test_int(void)
         cQueue_push(intQueue, i);
     }
 
+    printf("cQueue[5] = %d\r\n", cQueue_at(intQueue, 5));
+
     while (intQueue.queue.size > 0)
     {
         int data;

test/test_dList.c

@@ -208,7 +208,7 @@ static void test_to(void)
         if (!dList_pushBack(&list, &i, sizeof(i))) goto FAIL;
     }
 
-    node = dList_to(list, -11);
+    node = dList_to(list, -6);
     if (!node)
     {
         printf("dList_to fail\r\n");
@@ -326,9 +326,9 @@ static void test(void)
     // test_detach();
     // test_push();
     // test_pop();
-    // test_to();
+    test_to();
     // test_size();
-    test_append();
+    // test_append();
     // test_copy();
     // test_reverse();
     

test/test_sList.c

@@ -41,6 +41,7 @@ static void test_set(void)
     sList *list = NULL;
     int dataInt = 3;
     char *dataString = "Hello sList";
+    char outBuffer[32];
 
     list = sList_create();
     if (!list)
@@ -57,6 +58,9 @@ static void test_set(void)
     sList_set(list, dataString, strlen(dataString) + 1);
     printf("list->data %s\r\n", ((char *)(list->data)));
 
+    sList_get(list, outBuffer, sizeof(outBuffer));
+    printf("get data %s\r\n", outBuffer);
+
     sList_delete(list);
 }
 
@@ -210,7 +214,7 @@ static void test_to(void)
         if (!sList_pushBack(&list, &i, sizeof(i))) goto FAIL;
     }
 
-    node = sList_to(list, 10);
+    node = sList_to(list, 6);
     if (!node)
     {
         printf("sList_to fail\r\n");
@@ -320,10 +324,10 @@ static void test(void)
     // test_insert();
     // test_erase();
     // test_attach();
-    test_detach();
+    // test_detach();
     // test_push();
     // test_pop();
-    // test_to();
+    test_to();
     // test_size();
     // test_append();
     // test_copy();

test/test_valloc.c

@@ -1,10 +1,10 @@
-#include "test.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include "init.h"
 #include "valloc.h"
 
-void test_main(void)
+static void test(void)
 {
     void* p = NULL;
     printf("malloc %p\r\n", malloc(0));
@@ -19,10 +19,4 @@ void test_main(void)
     printf("count = %d\r\n", v_check_count());
     printf("used = %d\r\n", v_check_used());
 }
-
+init_export_app(test);
-std_return test_init(void) 
-{
-    test_main();
-
-    return E_OK;
-}

test/test_vlog.c

@@ -7,14 +7,40 @@ static void vlog_callback(char *buf, int len)
     printf("vlog_callback[%d]: %s", len, buf);
 }
 
+static void test_vlog(void)
+{
+    vlog(VLOG_CHANNEL_0,   "[VLOG_CHANNEL_0] vlog!\r\n");
+    vlog(VLOG_CHANNEL_1,   "[VLOG_CHANNEL_1] vlog!\r\n");
+    vlog(VLOG_CHANNEL_2,   "[VLOG_CHANNEL_2] vlog!\r\n");
+}
+
+static void test_channel(void)
+{
+    VLOG_DISABALE(VLOG_CHANNEL_0);
+    VLOG_ENABALE(VLOG_CHANNEL_1);
+
+    vlog(VLOG_CHANNEL_0,   "[VLOG_CHANNEL_0] vlog!\r\n");
+    vlog(VLOG_CHANNEL_1,   "[VLOG_CHANNEL_1] vlog!\r\n");
+    vlog(VLOG_CHANNEL_2,   "[VLOG_CHANNEL_2] vlog!\r\n");
+}
+
+static void test_offline(void)
+{
+    vlog_set_offline(VLOG_CHANNEL_0, "./test/file/log.txt");
+
+    for (int i = 0; i < 10; i++)
+    {
+        vlog(VLOG_CHANNEL_0, "vlog %d!\r\n", i);
+    }
+
+    vlog_set_offline(VLOG_CHANNEL_0, NULL);
+}
+
 static void test(void)
 {
-    // vlog_start_offline("log_20231227.txt");
+    // vlog_set_func(vlog_callback);
-    vlog_set_func(vlog_callback);
+    // test_vlog();
-    vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
+    // test_channel();
-    vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
+    test_offline();
-    vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
-    vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
-    // vlog_stop_offline();
 }
 init_export_app(test);