coffee/varch
1
0
Fork 0
mirror of https://gitee.com/Lamdonn/varch.git synced 2025-12-06 08:46:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Lamdonn 2024-07-30 00:57:01 +08:00
parent 96f9b08093
commit 6548f5bab8
19 changed files with 1807 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.en.md
View File

@ -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

4
README.md
View File

@ -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

180
doc/cQueue.md Normal file
View File

@ -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
```

558
doc/dList.md Normal file
View File

@ -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`型使用那就越界了。具体例子可以参考上文其他使用例子。

533
doc/sList.md Normal file
View File

@ -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`型使用那就越界了。具体例子可以参考上文其他使用例子。

4
doc/tool.md Normal file
View File

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

74
doc/valloc.md Normal file
View File

@ -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
```

124
doc/vlog.md Normal file
View File

@ -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种输出方向的各个通道状态掩码。

4
makefile
View File

@ -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

2
source/01_general/cQueue.h
View File

@ -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)

1
source/01_general/dList.h
View File

@ -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))

247
source/01_general/vlog.c
View File

@ -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 */
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 */
#define VLOG_CHANNEL_MAX (8)
/**
* \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, ...)
typedef struct
{
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 */
if (channel & channel_table)
for (c = 0; c < VLOG_CHANNEL_MAX; c++)
{
va_start(args, format);
/* 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 */
if (chn[c].console) printf(vlog_buffer);
len = vsnprintf(vlog_buffer, sizeof(vlog_buffer), format, args);
/* Output to offline file */
if (chn[c].file) fwrite(vlog_buffer, sizeof(char), len, chn[c].file);
/* Output to default console */
printf(vlog_buffer);
/* Output to offline file */
if (vlog_file) fwrite(vlog_buffer, sizeof(char), len, vlog_file);
/* Output to callback function */
if (vlog_func) vlog_func(vlog_buffer, len);
va_end(args);
/* Output to callback function */
if (chn[c].func) chn[c].func(vlog_buffer, len);
}
}
}
return len;
}
/**
* \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)
void vlog_set_filter(vlogChnType mask)
{
channel_table = channel;
cmask = mask;
}
/**
* \brief get vlog channel configuration
* \return channel configuration
*/
char vlog_get_channel(void)
vlogChnType vlog_get_filter(void)
{
return channel_table;
return cmask;
}
/**
* \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 vlog_set_console(vlogChnType channel, int console)
{
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+");
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)
for (c = 0; c < VLOG_CHANNEL_MAX; c++)
{
fclose(vlog_file);
vlog_file = 0;
/* match channel */
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;
}
/**
* \brief set additional vlog callback function
* \return none
*/
void vlog_set_func(vlog_func_t func)
vlogChnType vlog_get_offline(void)
{
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;
}

113
source/01_general/vlog.h
View File

@ -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>
/* vlog buffer size */
#define VLOG_BUFFER_SIZE (1024)
/* Version infomation */
/* 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_V_MAJOR 1
#define VLOG_V_MINOR 1
#define VLOG_V_PATCH 0
#define VLOG_ENABALE(c) vlog_set_channel(vlog_get_channel() | (1 << (c)))
#define VLOG_DISABALE(c) vlog_set_channel(vlog_get_channel() & ~(1 << (c)))
/* channel type define */
typedef unsigned char vlogChnType;
/* callback function define */
typedef void (*vlog_func_t)(char *buf, int len);
int vlog(char channel, const char *format, ...);
void vlog_set_channel(char channel);
char vlog_get_channel(void);
int vlog_start_offline(const char *filename);
void vlog_stop_offline(void);
void vlog_set_func(vlog_func_t func);
typedef void (*vlogFuncType)(char *buf, int len);
/* vlog buffer size */
#define VLOG_BUFFER_SIZE (1024)
/* vlog channel */
#define VLOG_CHANNEL_0 ((vlogChnType)(0x01))
#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))
/* Enable and disable a channel */
#define VLOG_ENABALE(c) vlog_set_filter(vlog_get_filter() | (c))
#define VLOG_DISABALE(c) vlog_set_filter(vlog_get_filter() & ~(c))
/**
* \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(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

10
test/file/log.txt Normal file
View File

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

2
test/test_cQueue.c
View File

@ -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;

6
test/test_dList.c
View File

@ -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();

10
test/test_sList.c
View File

@ -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();

12
test/test_valloc.c
View File

@ -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());
}
std_return test_init(void)
{
test_main();
return E_OK;
}
init_export_app(test);

40
test/test_vlog.c
View File

@ -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(VLOG_CHANNEL_0, "Hello vlog!\r\n");
vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
vlog(VLOG_CHANNEL_0, "Hello vlog!\r\n");
// vlog_stop_offline();
// vlog_set_func(vlog_callback);
// test_vlog();
// test_channel();
test_offline();
}
init_export_app(test);