#include "acl_define.h"
#include <string.h>

acl_mystring.h 的引用(Include)关系图:

此图展示该文件直接或间接的被哪些文件引用了:

类
struct	ACL_LINE_STATE

宏定义
#define	ACL_SAFE_STRNCPY(_obj, _src, _size)

#define	acl_mystrtok acl_strtok

#define	acl_mystrline acl_strline

#define	acl_mystr_trim acl_strtrim

#define	acl_mystr_strip acl_strstrip

#define	acl_mystr_truncate_byln acl_strtrunc_byln

#define	strrncasecmp acl_strrncasecmp

#define	strrncmp acl_strrncmp

类型定义
typedef struct ACL_LINE_STATE	ACL_LINE_STATE

函数
ACL_API char *	acl_lowercase (char *s)

ACL_API char *	acl_lowercase2 (char *s, size_t n)

ACL_API char *	acl_lowercase3 (const char s, char buf, size_t size)

ACL_API char *	acl_uppercase (char *s)

ACL_API char *	acl_uppercase2 (char *s, size_t n)

ACL_API char *	acl_uppercase3 (const char s, char buf, size_t size)

ACL_API char *	acl_strtok (char *src, const char sep)

ACL_API char *	acl_strline (char **src)

ACL_API char *	acl_strtrim (char *str)

ACL_API int	acl_strstrip (const char haystack, const char needle, char *buf, int bsize)

ACL_API int	acl_strtrunc_byln (char *str)

ACL_API int	acl_strrncasecmp (const char s1, const char s2, size_t n)

ACL_API int	acl_strrncmp (const char s1, const char s2, size_t n)

ACL_API char *	acl_rstrstr (const char haystack, const char needle)

ACL_API char *	acl_strcasestr (const char haystack, const char needle)

ACL_API char *	acl_rstrcasestr (const char haystack, const char needle)

ACL_API size_t	acl_strnlen (const char *s, size_t count)

ACL_API int	acl_strcasecmp (const char s1, const char s2)

ACL_API int	acl_strncasecmp (const char s1, const char s2, size_t n)

ACL_API int	acl_file_path_correct (const char psrc_file_path, char pbuf, int sizeb)

ACL_API int	acl_dir_correct (const char psrc_dir, char pbuf, int sizeb)

ACL_API int	acl_dir_getpath (const char pathname, char pbuf, int bsize)

ACL_API long long	acl_atoll (const char *s)

ACL_API acl_uint64	acl_atoui64 (const char *str)

ACL_API acl_int64	acl_atoi64 (const char *str)

ACL_API const char *	acl_ui64toa (acl_uint64 value, char *buf, size_t size)

ACL_API const char *	acl_i64toa (acl_int64 value, char *buf, size_t size)

ACL_API const char *	acl_i64toa_radix (acl_int64 value, char *buf, size_t size, int radix)

ACL_API const char *	acl_ui64toa_radix (acl_uint64 value, char *buf, size_t size, int radix)

ACL_API ACL_LINE_STATE *	acl_line_state_alloc (void)

ACL_API void	acl_line_state_free (ACL_LINE_STATE *state)

ACL_API ACL_LINE_STATE *	acl_line_state_reset (ACL_LINE_STATE *state, int offset)

ACL_API int	acl_find_blank_line (const char s, int n, ACL_LINE_STATE state)

宏定义说明

◆ acl_mystr_strip

#define acl_mystr_strip acl_strstrip

在文件 acl_mystring.h 第 121 行定义.

◆ acl_mystr_trim

#define acl_mystr_trim acl_strtrim

在文件 acl_mystring.h 第 109 行定义.

◆ acl_mystr_truncate_byln

#define acl_mystr_truncate_byln acl_strtrunc_byln

在文件 acl_mystring.h 第 129 行定义.

◆ acl_mystrline

#define acl_mystrline acl_strline

在文件 acl_mystring.h 第 101 行定义.

◆ acl_mystrtok

#define acl_mystrtok acl_strtok

在文件 acl_mystring.h 第 92 行定义.

◆ ACL_SAFE_STRNCPY

#define ACL_SAFE_STRNCPY	(	_obj,
		_src,
		_size
	)

值:

do {                \
    if (_size > 0) {                                            \
        size_t _n = strlen(_src);                               \
        _n = _n > (size_t ) _size - 1? (size_t) _size - 1 : _n; \
        memcpy(_obj, _src, _n);                                 \
        _obj[_n] = 0;                                           \
    }                                                           \
} while (0)

功能: 安全的字符串拷贝宏函数, 可以保证最后一个字节为 "\0"

参数

_obj	{char*} 目的内存区指针
_src	{const char*} 源字符串指针
_size	{int} 目的内存区的空间大小

在文件 acl_mystring.h 第 19 行定义.

◆ strrncasecmp

#define strrncasecmp acl_strrncasecmp

WINDOWS下不支持一些字符串比较函数

在文件 acl_mystring.h 第 216 行定义.

◆ strrncmp

#define strrncmp acl_strrncmp

在文件 acl_mystring.h 第 219 行定义.

类型定义说明

◆ ACL_LINE_STATE

typedef struct ACL_LINE_STATE ACL_LINE_STATE

函数说明

◆ acl_atoi64()

ACL_API acl_int64 acl_atoi64 ( const char * str )

将数据字符串转换为64位符号长整型

参数

str	{const char*} 字符串指针

返回: {acl_int64} 无符号长整型

◆ acl_atoll()

ACL_API long long acl_atoll ( const char * s )

将数据字符串转换为64位有符号长整型

参数

s	{const char*} 字符串指针

返回: {long long} 有符号长整型

◆ acl_atoui64()

ACL_API acl_uint64 acl_atoui64 ( const char * str )

将数据字符串转换为64位无符号长整型

参数

str	{const char*} 字符串指针

返回: {acl_uint64} 无符号长整型

◆ acl_dir_correct()

ACL_API int acl_dir_correct	(	const char *	psrc_dir,
		char *	pbuf,
		int	sizeb
	)

◆ acl_dir_getpath()

ACL_API int acl_dir_getpath	(	const char *	pathname,
		char *	pbuf,
		int	bsize
	)

◆ acl_file_path_correct()

ACL_API int acl_file_path_correct	(	const char *	psrc_file_path,
		char *	pbuf,
		int	sizeb
	)

◆ acl_find_blank_line()

ACL_API int acl_find_blank_line	(	const char *	s,
		int	n,
		ACL_LINE_STATE *	state
	)

从所给数据缓冲区中查找一个空行(空行可以为: \r
或
)，该函数支持流式解析，可以循环调用本函数

参数

s	{const char*} 传入数据缓冲区地址
n	{int} s 数据缓冲区的长度
state	{ACL_LINE_STATE*} 由 acl_line_state_alloc 分配的对象

返回: {int} 剩余的的字节数

◆ acl_i64toa()

ACL_API const char* acl_i64toa	(	acl_int64	value,
		char *	buf,
		size_t	size
	)

将64位符号长整型转换为字符串

参数

value	{acl_int64} 64位符号长整型
buf	{char*} 用来存取转换结果的内存空间
size	{sizt_t} buf 的空间大小，其中要求其最小为21个字节

返回: {const char*} 转换的结果，如果转换成功则不为空，否则为空

◆ acl_i64toa_radix()

ACL_API const char* acl_i64toa_radix	(	acl_int64	value,
		char *	buf,
		size_t	size,
		int	radix
	)

将64位符号长整型转换为某进制的字符串

参数

value	{acl_int64} 64位符号长整型
buf	{char*} 用来存取转换结果的内存空间
size	{sizt_t} buf 的空间大小，其中要求其最小为21个字节
radix	{int} 进制, 如: 8 表示八进制, 10 表示十进制, 16 表示十六进制

返回: {const char*} 转换的结果，如果转换成功则不为空，否则为空

◆ acl_line_state_alloc()

ACL_API ACL_LINE_STATE* acl_line_state_alloc ( void )

分配一个 ACL_LINE_STATE 对象用作 acl_find_blank_line 函数的参数

返回: {ACL_LINE_STATE*} 永远返回非空指针

◆ acl_line_state_free()

ACL_API void acl_line_state_free ( ACL_LINE_STATE * state )

释放由 acl_line_state_alloc 分配的 ACL_LINE_STATE 对象

参数

state {ACL_LINE_STATE*} 非空 ACL_LINE_STATE 对象

◆ acl_line_state_reset()

ACL_API ACL_LINE_STATE* acl_line_state_reset	(	ACL_LINE_STATE *	state,
		int	offset
	)

重置 ACL_LINE_STATE 对象的状态

参数

state	{ACL_LINE_STATE*} 由 acl_line_state_alloc 动态分配的对象或者栈变量或直接调用 malloc 或其它内存池分配的对象，但只有 acl_line_state_alloc 分配的对象才可以使用 acl_line_state_free 释放
offset	{int} 设置 ACL_LINE_STATE 对象中 offset 的初始值

返回: {ACL_LINE_STATE*} 传入的 state 对象指针

◆ acl_lowercase()

ACL_API char* acl_lowercase ( char * s )

将字符串转换为小写，直接在原内存空间进行操作

参数

s	{char *} 给定的字符串

返回: {char*} 成功返回字符串地址，否则返回 NULL

◆ acl_lowercase2()

ACL_API char* acl_lowercase2	(	char *	s,
		size_t	n
	)

将给定字符串的前 n 个字节转换为小写

参数

s	{char *} 给定的字符串
n	{int} 最多仅转换的字节数

返回: {char*} 成功返回字符串地址，否则返回 NULL

◆ acl_lowercase3()

ACL_API char* acl_lowercase3	(	const char *	s,
		char *	buf,
		size_t	size
	)

将给定字符串转换为小写，结果存储于另一个内存区内

参数

s	{const char*} 源字符串
buf	{char*} 存储转换结果的内存指针
size	{size_t} buf 的空间大小

返回: {char*} 成功返回字符串地址，否则返回 NULL

◆ acl_rstrcasestr()

ACL_API char* acl_rstrcasestr	(	const char *	haystack,
		const char *	needle
	)

从后向前扫描查找字符串，大小写不敏感

参数

haystack	{char *} 源字符串
needle	{const char *} 匹配查找的字符串

返回: {char *} != NULL: Ok, NULL: 未发现

◆ acl_rstrstr()

ACL_API char* acl_rstrstr	(	const char *	haystack,
		const char *	needle
	)

从后向前扫描查找字符串，大小写敏感

参数

haystack	{char *} 源字符串
needle	{const char *} 匹配查找的字符串

返回: {char *} != NULL: Ok, NULL: 未发现

◆ acl_strcasecmp()

ACL_API int acl_strcasecmp	(	const char *	s1,
		const char *	s2
	)

比较两个字符串是否相同，大小写不敏感

参数

s1	{const char*}
s2	{cosnt char*}

返回: {int} 0: 相同; < 0: s1 < s2; > 0: s1 > s2

◆ acl_strcasestr()

ACL_API char* acl_strcasestr	(	const char *	haystack,
		const char *	needle
	)

从前向后扫描查找字符串，大小写不敏感

参数

haystack	{const char *} 源字符串
needle	{const char *} 匹配查找的字符串

返回: {char *} != NULL: Ok, NULL: 未发现

◆ acl_strline()

ACL_API char* acl_strline ( char ** src )

获得一个逻辑行, 如果某行的尾部由连接符 "\\" 连接，则将下一行合并至本行, 同时将一行字符串中的以及转义字符回车换行("\r\n" or "\n")去掉

参数

src	{char**} 源字符串的地址指针

返回: {char*} 返回一行数据, 如果返回空则表示没有可用的逻辑行

◆ acl_strncasecmp()

ACL_API int acl_strncasecmp	(	const char *	s1,
		const char *	s2,
		size_t	n
	)

比较两个字符串是否相同，大小写不敏感，同时限定最大比较长度

参数

s1	{const char*}
s2	{cosnt char*}
n	{size_t} 限定比较的最大长度

返回: {int} 0: 相同; < 0: s1 < s2; > 0: s1 > s2

◆ acl_strnlen()

ACL_API size_t acl_strnlen	(	const char *	s,
		size_t	count
	)

计算给定字符串的长度，但限制了最大计算长度，以免产生越界现象，要比 strlen 安全，如，如果给定字符串没有以 "\0" 结尾，则该函数就不会产生越界

参数

s	{const char*} 字符串
count	{size_t} 最大计算长度

返回: {size_t} 字符串 s 的实际长度

◆ acl_strrncasecmp()

ACL_API int acl_strrncasecmp	(	const char *	s1,
		const char *	s2,
		size_t	n
	)

从后向前比较两个给定字符串，大小写不敏感且限定最大比较范围

参数

s1	{const char*} 字符串地址
s2	{const char*} 字符串地址
n	{size_t} 最大比较范围

返回: {int} 比较结果. 0: 相等, >0: 第一个字符串大于第二个字符串, < 0: 第一个字符串小第二个字符串

◆ acl_strrncmp()

ACL_API int acl_strrncmp	(	const char *	s1,
		const char *	s2,
		size_t	n
	)

从后向前比较两个给定字符串, 大小写敏感且限定最大比较范围

参数

s1	{const char*} 字符串地址
s2	{const char*} 字符串地址
n	{size_t} 最大比较范围

返回: {int} 比较结果. 0: 相等, >0: 第一个字符串大于第二个字符串, < 0: 第一个字符串小第二个字符串

◆ acl_strstrip()

ACL_API int acl_strstrip	(	const char *	haystack,
		const char *	needle,
		char *	buf,
		int	bsize
	)

从源字符串中去掉给定字符串

参数

haystack	{const char*} 源字符串
needle	{const char*} 需要从源字符串中被整体去掉的字符串
buf	{char*} 存储结果的内存开始位置
bsize	{int} buf 的空间大小

返回: {int} 拷贝至 buf 中的字符串长度

◆ acl_strtok()

ACL_API char* acl_strtok	(	char **	src,
		const char *	sep
	)

将给定字符串用另一个分隔符字符串进行分割

参数

src	{char**} 需要被分割的字符串的地址的指针，必须是非空指针，可以是空字符串，此时该函数返回 NULL
sep	{const char*} 分隔符，非空字符串

返回: {char*} 当前被分割的字符串的指针位置，src 指向下一个将要进行分隔的起始位置； 1）当返回 NULL 时，则表示分隔过程结束，此时 src 的指针位置被赋予 '\0'； 2）当返回非 NULL 时，则此时 src 指向的字符串可能是或不是空字符串，如果指向空字符串，则再次分隔时函数肯定能返回 NULL，否则，当再次分隔时函数返回非 NULL 指针举例: 源字符串："abcd=|efg=|hijk", 分隔符 "=|"，则第一次分隔后 src 将指向 "efg"，而返回的地址为 "abcd"

◆ acl_strtrim()

ACL_API char* acl_strtrim ( char * str )

去掉给定字符串中的 " ", "\t"

参数

str	{char*} 源字符串

返回: {char*} 与源字符串相同的地址

◆ acl_strtrunc_byln()

ACL_API int acl_strtrunc_byln ( char * str )

从源字符串中找到一行的结束位置并去掉包含回车换行符及其以后的字符串

参数

str	{char*} 源字符串

返回: {int} 0 表示成功，-1表示失败, 也许应该返回最后转换结果的长度!

◆ acl_ui64toa()

ACL_API const char* acl_ui64toa	(	acl_uint64	value,
		char *	buf,
		size_t	size
	)

将64位无符号长整型转换为字符串

参数

value	{acl_uint64} 64位无符号长整型
buf	{char*} 用来存取转换结果的内存空间
size	{sizt_t} buf 的空间大小，其中要求其最小为21个字节

返回: {const char*} 转换的结果，如果转换成功则不为空，否则为空

◆ acl_ui64toa_radix()

ACL_API const char* acl_ui64toa_radix	(	acl_uint64	value,
		char *	buf,
		size_t	size,
		int	radix
	)

将64位无符号长整型转换为某进制的字符串

参数

value	{acl_int64} 64位符号长整型
buf	{char*} 用来存取转换结果的内存空间
size	{sizt_t} buf 的空间大小，其中要求其最小为21个字节
radix	{int} 进制, 如: 8 表示八进制, 10 表示十进制, 16 表示十六进制

返回: {const char*} 转换的结果，如果转换成功则不为空，否则为空

◆ acl_uppercase()

ACL_API char* acl_uppercase ( char * s )

将字符串转换为大写，直接在原内存空间进行操作

参数

s	{char *} 给定的字符串

返回: {char*} 成功返回字符串地址，否则返回 NULL

◆ acl_uppercase2()

ACL_API char* acl_uppercase2	(	char *	s,
		size_t	n
	)

将字符串转换为大写，直接在原内存空间进行操作, 最大转换长度有限制

参数

s	{char *} 给定的字符串
n	{int} 最多仅转换的字节数

返回: {char*} 成功返回字符串地址，否则返回 NULL

◆ acl_uppercase3()

ACL_API char* acl_uppercase3	(	const char *	s,
		char *	buf,
		size_t	size
	)

将给定字符串的前 n 个字节转换为大写

参数

s	{char *} 给定的字符串
buf	{char*} 存储转换结果的内存区
size	{size_t} buf 的空间大小(字节)

返回: {char*} 成功返回字符串地址，否则返回 NULL