Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/url.c
|
/**
* File: url.c
* Author: AWTK Develop Team
* Brief: URL parser
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-25 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/url.h"
#include "tkc/utils.h"
#include "tkc/object_default.h"
static url_t* url_parse(url_t* url, const char* surl);
url_t* url_create(const char* surl) {
url_t* url = TKMEM_ZALLOC(url_t);
return_value_if_fail(url != NULL, NULL);
str_init(&(url->url), 0);
if (surl != NULL) {
return url_parse(url, surl);
}
return url;
}
typedef enum _state_t {
STATE_START = 0,
STATE_SCHEMA,
STATE_HOST,
STATE_PORT,
STATE_PATH,
STATE_KEY,
STATE_VALUE
} state_t;
#define STR_FILE "file"
#define NUM_DEFAULT_PORT 80
#define STR_SCHEMA_DEFAULT "http"
static url_t* url_fix(url_t* url) {
if (url->port == 0) {
if (tk_str_eq(url->schema, "http")) {
url->port = 80;
url->fixed_port = TRUE;
} else if (tk_str_eq(url->schema, "https")) {
url->port = 443;
url->fixed_port = TRUE;
} else if (tk_str_eq(url->schema, "ftp")) {
url->port = 21;
url->fixed_port = TRUE;
}
}
return url;
}
static url_t* url_parse(url_t* url, const char* surl) {
str_t str;
const char* p = surl;
const char* start = surl;
state_t state = STATE_START;
return_value_if_fail(str_init(&str, 100) != NULL, url);
while (TRUE) {
switch (state) {
case STATE_START: {
if (!tk_isspace(*p)) {
if (*p == '/' || *p == '\\' || strncmp(p, "./", 2) == 0 || strncmp(p, ".\\", 2) == 0) {
goto_error_if_fail(url_set_schema(url, STR_FILE) == RET_OK);
state = STATE_PATH;
} else {
state = STATE_SCHEMA;
}
start = p;
}
break;
}
case STATE_SCHEMA: {
if (*p == ':' || *p == '/' || *p == '?' || *p == '\0') {
goto_error_if_fail(str_set_with_len(&str, start, p - start) == RET_OK);
if (strncmp(p, "://", 3) == 0) {
/*http://zlg.cn*/
p += 2;
start = p + 1;
state = STATE_HOST;
goto_error_if_fail(url_set_schema(url, str.str) == RET_OK);
} else if (strncmp(p, ":/", 2) == 0 || strncmp(p, ":\\", 2) == 0) {
/*c:/a/b/c */
goto_error_if_fail(url_set_schema(url, STR_FILE) == RET_OK);
goto_error_if_fail(str.size == 1);
state = STATE_PATH;
} else if (*p == ':') {
/*zlg.cn:80*/
goto_error_if_fail(url_set_schema(url, STR_SCHEMA_DEFAULT) == RET_OK);
goto_error_if_fail(url_set_host(url, str.str) == RET_OK);
state = STATE_PORT;
start = p + 1;
} else if (*p == '/') {
/*zlg.cn:80*/
goto_error_if_fail(url_set_schema(url, STR_SCHEMA_DEFAULT) == RET_OK);
goto_error_if_fail(url_set_port(url, NUM_DEFAULT_PORT) == RET_OK);
goto_error_if_fail(url_set_host(url, str.str) == RET_OK);
state = STATE_PATH;
start = p + 1;
} else if (*p == '?') {
/*zlg.cn?id=1*/
goto_error_if_fail(url_set_schema(url, STR_SCHEMA_DEFAULT) == RET_OK);
goto_error_if_fail(url_set_port(url, NUM_DEFAULT_PORT) == RET_OK);
goto_error_if_fail(url_set_host(url, str.str) == RET_OK);
state = STATE_KEY;
start = p + 1;
} else {
/*zlg.cn*/
goto_error_if_fail(url_set_schema(url, STR_SCHEMA_DEFAULT) == RET_OK);
goto_error_if_fail(url_set_port(url, NUM_DEFAULT_PORT) == RET_OK);
goto_error_if_fail(url_set_host(url, str.str) == RET_OK);
start = p + 1;
}
if (tk_str_eq(url->schema, STR_FILE)) {
state = STATE_PATH;
}
}
break;
}
case STATE_HOST: {
if (*p == ':' || *p == '?' || *p == '/' || *p == '\0') {
goto_error_if_fail(str_set_with_len(&str, start, p - start) == RET_OK);
goto_error_if_fail(url_set_host(url, str.str) == RET_OK);
switch (*p) {
case ':': {
state = STATE_PORT;
break;
}
case '?': {
state = STATE_KEY;
break;
}
case '/': {
p--;
state = STATE_PATH;
break;
}
default:
break;
}
start = p + 1;
}
break;
}
case STATE_PORT: {
if (*p == '@' || *p == '?' || *p == '/' || *p == '\0') {
goto_error_if_fail(str_set_with_len(&str, start, p - start) == RET_OK);
switch (*p) {
case '@': {
/*http://username:[email protected]*/
goto_error_if_fail(url_set_user_name(url, url->host) == RET_OK);
goto_error_if_fail(url_set_password(url, str.str) == RET_OK);
TKMEM_FREE(url->host);
state = STATE_HOST;
break;
}
case '?': {
/*https://www.zlg.cn:80?key=value*/
state = STATE_KEY;
url_set_port(url, tk_atoi(str.str));
break;
}
case '/': {
/*https://www.zlg.cn:80/awtk*/
state = STATE_PATH;
url_set_port(url, tk_atoi(str.str));
break;
}
default: {
/*https://www.zlg.cn:80*/
url_set_port(url, tk_atoi(str.str));
break;
}
}
start = p + 1;
}
break;
}
case STATE_PATH: {
if (*p == '?' || *p == '\0') {
goto_error_if_fail(str_set_with_len(&str, start, p - start) == RET_OK);
goto_error_if_fail(url_set_path(url, str.str) == RET_OK);
state = STATE_KEY;
start = p + 1;
}
break;
}
case STATE_KEY: {
if (*p == '=' || *p == '\0') {
goto_error_if_fail(str_set_with_len(&str, start, p - start) == RET_OK);
state = STATE_VALUE;
start = p + 1;
}
break;
}
case STATE_VALUE: {
if (*p == '&' || *p == '\0') {
uint32_t name_size = str.size;
str.size++;
goto_error_if_fail(str_append_with_len(&str, start, p - start) == RET_OK);
goto_error_if_fail(url_set_param(url, str.str, str.str + name_size + 1) == RET_OK);
state = STATE_KEY;
start = p + 1;
}
break;
}
}
if (*p) {
p++;
} else {
break;
}
}
str_reset(&str);
return url_fix(url);
error:
str_reset(&str);
url_destroy(url);
return NULL;
}
ret_t url_set_schema(url_t* url, const char* schema) {
return_value_if_fail(url != NULL && schema != NULL, RET_BAD_PARAMS);
url->schema = tk_str_copy(url->schema, schema);
return RET_OK;
}
ret_t url_set_user_name(url_t* url, const char* user_name) {
return_value_if_fail(url != NULL && user_name != NULL, RET_BAD_PARAMS);
url->user_name = tk_str_copy(url->user_name, user_name);
return RET_OK;
}
ret_t url_set_password(url_t* url, const char* password) {
return_value_if_fail(url != NULL && password != NULL, RET_BAD_PARAMS);
url->password = tk_str_copy(url->password, password);
return RET_OK;
}
ret_t url_set_host(url_t* url, const char* host) {
return_value_if_fail(url != NULL && host != NULL, RET_BAD_PARAMS);
url->host = tk_str_copy(url->host, host);
return RET_OK;
}
ret_t url_set_port(url_t* url, int32_t port) {
return_value_if_fail(url != NULL, RET_BAD_PARAMS);
url->port = port;
url->fixed_port = FALSE;
return RET_OK;
}
ret_t url_set_path(url_t* url, const char* path) {
return_value_if_fail(url != NULL && path != NULL, RET_BAD_PARAMS);
url->path = tk_str_copy(url->path, path);
return RET_OK;
}
ret_t url_set_param(url_t* url, const char* name, const char* value) {
return_value_if_fail(url != NULL && name != NULL && value != NULL, RET_BAD_PARAMS);
if (url->params == NULL) {
url->params = object_default_create();
}
return_value_if_fail(url->params != NULL, RET_OOM);
return tk_object_set_prop_str(url->params, name, value);
}
const char* url_get_param(url_t* url, const char* name) {
return_value_if_fail(url != NULL && name != NULL, NULL);
if (url->params == NULL) {
return NULL;
}
return tk_object_get_prop_str(url->params, name);
}
int32_t url_get_param_int32(url_t* url, const char* name, int32_t defval) {
const char* value = url_get_param(url, name);
if (value != NULL) {
return tk_atoi(value);
} else {
return defval;
}
}
bool_t url_get_param_bool(url_t* url, const char* name, bool_t defval) {
const char* value = url_get_param(url, name);
if (value != NULL) {
return tk_atob(value);
} else {
return defval;
}
}
static ret_t url_on_visit_param(void* ctx, const void* data) {
named_value_t* nv = (named_value_t*)data;
str_t* str = (str_t*)ctx;
if (str->str[str->size - 1] != '?') {
str_append_char(str, '&');
}
str_append_more(str, nv->name, "=", value_str(&(nv->value)), NULL);
return RET_OK;
}
const char* url_to_string(url_t* url) {
str_t* str = NULL;
return_value_if_fail(url != NULL, NULL);
str = &(url->url);
str_extend(str, 256);
str_clear(str);
if (url->schema != NULL) {
str_append_more(str, url->schema, "://", NULL);
}
if (url->user_name != NULL) {
str_append(str, url->user_name);
if (url->password != NULL) {
str_append_char(str, ':');
str_append(str, url->password);
}
str_append_char(str, '@');
}
if (url->host != NULL) {
str_append(str, url->host);
if (url->port != 0 && !(url->fixed_port)) {
str_append_char(str, ':');
str_append_int(str, url->port);
}
}
if (url->path != NULL) {
str_append(str, url->path);
}
if (url->params != NULL) {
str_append_char(str, '?');
tk_object_foreach_prop(url->params, url_on_visit_param, str);
}
return str->str;
}
ret_t url_destroy(url_t* url) {
return_value_if_fail(url != NULL, RET_BAD_PARAMS);
TKMEM_FREE(url->schema);
TKMEM_FREE(url->host);
TKMEM_FREE(url->user_name);
TKMEM_FREE(url->password);
TKMEM_FREE(url->path);
TK_OBJECT_UNREF(url->params);
str_reset(&(url->url));
TKMEM_FREE(url);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_darray_thread.h
|
/**
* File: action_darray_thread.h
* Author: AWTK Develop Team
* Brief: action_darray_thread
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2022-3-25 vih created
*
*/
#ifndef TK_ACTION_DARRAY_THREAD_H
#define TK_ACTION_DARRAY_THREAD_H
#include "tkc/thread.h"
#include "tkc/action_thread.h"
#include "tkc/waitable_action_darray.h"
BEGIN_C_DECLS
struct _action_darray_thread_t;
typedef struct _action_darray_thread_t action_darray_thread_t;
typedef ret_t (*action_darray_thread_on_idle_t)(void* ctx, action_darray_thread_t* thread);
typedef ret_t (*action_darray_thread_on_quit_t)(void* ctx, action_darray_thread_t* thread);
typedef enum {
ACTION_DARRAY_THREAD_STRATEGY_NONE = 0,
ACTION_DARRAY_THREAD_STRATEGY_REPLACE, /* 替换旧的 qaction */
ACTION_DARRAY_THREAD_STRATEGY_FLUSH, /* 删除旧的 qaction，往尾部添加新的 qaction */
} action_darray_thread_strategy_t;
/**
* @class action_darray_thread_t
* 执行action的线程。
*
*> 每个线程都有一个action darray，可以是共享的darray，也可以是私有的darray。
*/
struct _action_darray_thread_t {
/**
* @property {tk_thread_t*} thread
* @annotation ["readable"]
* 线程对象。
*/
tk_thread_t* thread;
/**
* @property {waitable_action_darray_t*} darray
* @annotation ["readable"]
* action darray。
*/
waitable_action_darray_t* darray;
/**
* @property {uint32_t} executed_actions_nr
* @annotation ["readable"]
* 已经执行action的个数。
*/
uint32_t executed_actions_nr;
/**
* @property {uint32_t} idle_interval
* @annotation ["readable"]
* 空闲时的时间间隔。
*/
uint32_t idle_interval;
/*private*/
/*请求退出*/
bool_t quit;
/*已经退出*/
bool_t quited;
/*是否是共享的darray*/
bool_t is_shared_darray;
void* on_idle_ctx;
void* on_quit_ctx;
action_darray_thread_on_idle_t on_idle;
action_darray_thread_on_quit_t on_quit;
action_darray_thread_strategy_t strategy;
};
/**
* @method action_darray_thread_create
* @annotation ["constructor"]
* 创建action_darray_thread对象。
*
* @return {action_darray_thread_t*} action_darray_thread对象。
*/
action_darray_thread_t* action_darray_thread_create(void);
/**
* @method action_darray_thread_create_ex
* @annotation ["constructor"]
* 创建action_darray_thread对象。
*
* @param {const char*} name 名称。
* @param {uint32_t} stack_size 栈的大小。
* @param {tk_thread_priority_t} priority 优先级。
*
* @return {action_darray_thread_t*} action_darray_thread对象。
*/
action_darray_thread_t* action_darray_thread_create_ex(const char* name, uint32_t stack_size,
tk_thread_priority_t priority);
/**
* @method action_darray_thread_create_with_darray
* @annotation ["constructor"]
* 创建action_darray_thread对象。
*
* @param {waitable_action_darray_t*} darray darray对象。
*
* @return {action_darray_thread_t*} action_darray_thread对象。
*/
action_darray_thread_t* action_darray_thread_create_with_darray(waitable_action_darray_t* darray);
/**
* @method action_darray_thread_create_with_darray_ex
* @annotation ["constructor"]
* 创建action_darray_thread对象。
*
* @param {waitable_action_darray_t*} darray darray对象。
* @param {const char*} name 名称。
* @param {uint32_t} stack_size 栈的大小。
* @param {tk_thread_priority_t} priority 优先级。
*
* @return {action_darray_thread_t*} action_darray_thread对象。
*/
action_darray_thread_t* action_darray_thread_create_with_darray_ex(waitable_action_darray_t* darray,
const char* name,
uint32_t stack_size,
tk_thread_priority_t priority);
/**
* @method action_darray_thread_set_strategy
* 设置策略
*
* @param {action_darray_thread_t*} thread action_darray_thread对象。
* @param {action_darray_thread_strategy_t} strategy 策略
*
* @return {ret_t} 返回 ret_t值
*/
ret_t action_darray_thread_set_strategy(action_darray_thread_t* thread,
action_darray_thread_strategy_t strategy);
/**
* @method action_darray_thread_set_idle_interval
* 设置空闲时的时间间隔。
* @param {action_darray_thread_t*} thread action_darray_thread对象。
* @param {uint32_t} interval 时间间隔(毫秒)。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_darray_thread_set_idle_interval(action_darray_thread_t* thread, uint32_t interval);
/**
* @method action_darray_thread_exec
* 让线程执行action。
*
* @param {action_darray_thread_t*} thread action_darray_thread对象。
* @param {qaction_t*} action action对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_darray_thread_exec(action_darray_thread_t* thread, qaction_t* action);
/**
* @method action_darray_thread_set_on_idle
* 设置空闲时的回调函数。
*
* @param {action_darray_thread_t*} thread action_darray_thread对象。
* @param {action_darray_thread_on_idle_t} on_idle 空闲时的回调函数。
* @param {void*} ctx 回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_darray_thread_set_on_idle(action_darray_thread_t* thread,
action_darray_thread_on_idle_t on_idle, void* ctx);
/**
* @method action_darray_thread_set_on_quit
* 设置退出时的回调函数。
*
* @param {action_darray_thread_t*} thread action_darray_thread对象。
* @param {action_darray_thread_on_quit_t} on_quit 退出时的回调函数。
* @param {void*} ctx 回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_darray_thread_set_on_quit(action_darray_thread_t* thread,
action_darray_thread_on_quit_t on_quit, void* ctx);
/**
* @method action_darray_thread_destroy
* 销毁。
*
* @param {action_darray_thread_t*} thread action_darray_thread对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t action_darray_thread_destroy(action_darray_thread_t* thread);
END_C_DECLS
#endif /*TK_ACTION_DARRAY_THREAD_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/buffer.c
|
/**
* File: buffer.c
* Author: AWTK Develop Team
* Brief: buffer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-15 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/buffer.h"
wbuffer_t* wbuffer_create(void* data, uint32_t capacity) {
wbuffer_t* buffer = NULL;
return_value_if_fail(data != NULL && capacity > 0, NULL);
buffer = TKMEM_ZALLOC(wbuffer_t);
return wbuffer_init(buffer, data, capacity);
}
wbuffer_t* wbuffer_create_extendable(void) {
wbuffer_t* buffer = TKMEM_ZALLOC(wbuffer_t);
return wbuffer_init_extendable(buffer);
}
ret_t wbuffer_destroy(wbuffer_t* wbuffer) {
return_value_if_fail(wbuffer != NULL, RET_BAD_PARAMS);
wbuffer_deinit(wbuffer);
TKMEM_FREE(wbuffer);
return RET_OK;
}
rbuffer_t* rbuffer_create(const void* data, uint32_t capacity) {
rbuffer_t* buffer = NULL;
return_value_if_fail(data != NULL && capacity > 0, NULL);
buffer = TKMEM_ZALLOC(rbuffer_t);
return rbuffer_init(buffer, data, capacity);
}
ret_t rbuffer_deinit(rbuffer_t* rbuffer) {
return RET_OK;
}
ret_t rbuffer_destroy(rbuffer_t* rbuffer) {
return_value_if_fail(rbuffer != NULL, RET_BAD_PARAMS);
TKMEM_FREE(rbuffer);
return RET_OK;
}
wbuffer_t* wbuffer_init(wbuffer_t* wbuffer, void* data, uint32_t capacity) {
return_value_if_fail(wbuffer != NULL && data != NULL, NULL);
wbuffer->data = (uint8_t*)data;
wbuffer->cursor = 0;
wbuffer->extendable = FALSE;
wbuffer->capacity = capacity;
return wbuffer;
}
ret_t wbuffer_rewind(wbuffer_t* wbuffer) {
return_value_if_fail(wbuffer != NULL, RET_BAD_PARAMS);
wbuffer->cursor = 0;
return RET_OK;
}
ret_t wbuffer_extend_capacity(wbuffer_t* wbuffer, uint32_t capacity) {
uint8_t* data = NULL;
return_value_if_fail(wbuffer != NULL, RET_BAD_PARAMS);
if (capacity <= wbuffer->capacity) {
return RET_OK;
}
return_value_if_fail(wbuffer->extendable, RET_FAIL);
capacity = tk_max(capacity, wbuffer->capacity * 1.5);
data = (uint8_t*)TKMEM_REALLOC(wbuffer->data, capacity);
if (data != NULL) {
wbuffer->data = data;
wbuffer->capacity = capacity;
memset(data + wbuffer->cursor, 0x00, capacity - wbuffer->cursor);
return RET_OK;
}
return RET_OOM;
}
static ret_t wbuffer_extend_delta(wbuffer_t* wbuffer, uint32_t delta) {
uint32_t capacity = 0;
return_value_if_fail(wbuffer != NULL, RET_BAD_PARAMS);
capacity = wbuffer->cursor + delta + 1;
return wbuffer_extend_capacity(wbuffer, capacity);
}
ret_t wbuffer_deinit(wbuffer_t* wbuffer) {
return_value_if_fail(wbuffer != NULL, RET_BAD_PARAMS);
if (wbuffer->extendable && wbuffer->data != NULL) {
TKMEM_FREE(wbuffer->data);
}
memset(wbuffer, 0x00, sizeof(wbuffer_t));
return RET_OK;
}
wbuffer_t* wbuffer_init_extendable(wbuffer_t* wbuffer) {
return_value_if_fail(wbuffer != NULL, NULL);
wbuffer->data = 0;
wbuffer->cursor = 0;
wbuffer->capacity = 0;
wbuffer->extendable = TRUE;
return wbuffer;
}
ret_t wbuffer_skip(wbuffer_t* wbuffer, int32_t delta) {
int32_t cursor = 0;
return_value_if_fail(wbuffer != NULL, RET_BAD_PARAMS);
return_value_if_fail((wbuffer->extendable || wbuffer->data != NULL), RET_BAD_PARAMS);
cursor = wbuffer->cursor + delta;
return_value_if_fail(cursor >= 0, RET_BAD_PARAMS);
return_value_if_fail(wbuffer_extend_capacity(wbuffer, cursor) == RET_OK, RET_BAD_PARAMS);
wbuffer->cursor = cursor;
return RET_OK;
}
ret_t wbuffer_write_uint8(wbuffer_t* wbuffer, uint8_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
wbuffer->data[wbuffer->cursor++] = value;
return RET_OK;
}
ret_t wbuffer_write_uint16(wbuffer_t* wbuffer, uint16_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_uint32(wbuffer_t* wbuffer, uint32_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_uint64(wbuffer_t* wbuffer, uint64_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_int8(wbuffer_t* wbuffer, int8_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
wbuffer->data[wbuffer->cursor++] = value;
return RET_OK;
}
ret_t wbuffer_write_int16(wbuffer_t* wbuffer, int16_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_int32(wbuffer_t* wbuffer, int32_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_int64(wbuffer_t* wbuffer, int64_t value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_float(wbuffer_t* wbuffer, float value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_double(wbuffer_t* wbuffer, double value) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, sizeof(value)) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, &value, sizeof(value));
wbuffer->cursor += sizeof(value);
return RET_OK;
}
ret_t wbuffer_write_binary(wbuffer_t* wbuffer, const void* data, uint32_t size) {
return_value_if_fail(wbuffer_extend_delta(wbuffer, size) == RET_OK, RET_BAD_PARAMS);
memcpy(wbuffer->data + wbuffer->cursor, data, size);
wbuffer->cursor += size;
return RET_OK;
}
ret_t wbuffer_write_value(wbuffer_t* wbuffer, const value_t* v) {
ret_t ret = RET_FAIL;
return_value_if_fail(wbuffer != NULL && v != NULL, RET_BAD_PARAMS);
if (VALUE_TYPE_WSTRING == v->type) {
ret = wbuffer_write_uint8(wbuffer, VALUE_TYPE_STRING);
} else {
ret = wbuffer_write_uint8(wbuffer, v->type);
}
return_value_if_fail(ret == RET_OK, ret);
switch (v->type) {
case VALUE_TYPE_BOOL: {
ret = wbuffer_write_uint8(wbuffer, value_bool(v));
break;
}
case VALUE_TYPE_UINT8: {
ret = wbuffer_write_uint8(wbuffer, value_uint8(v));
break;
}
case VALUE_TYPE_INT8: {
ret = wbuffer_write_int8(wbuffer, value_int8(v));
break;
}
case VALUE_TYPE_UINT16: {
ret = wbuffer_write_uint16(wbuffer, value_uint16(v));
break;
}
case VALUE_TYPE_INT16: {
ret = wbuffer_write_int16(wbuffer, value_int16(v));
break;
}
case VALUE_TYPE_UINT32: {
ret = wbuffer_write_uint32(wbuffer, value_uint32(v));
break;
}
case VALUE_TYPE_INT32: {
ret = wbuffer_write_int32(wbuffer, value_int32(v));
break;
}
case VALUE_TYPE_UINT64: {
ret = wbuffer_write_uint64(wbuffer, value_uint16(v));
break;
}
case VALUE_TYPE_INT64: {
ret = wbuffer_write_int64(wbuffer, value_int64(v));
break;
}
case VALUE_TYPE_FLOAT32: {
ret = wbuffer_write_float(wbuffer, value_float32(v));
break;
}
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_DOUBLE: {
ret = wbuffer_write_double(wbuffer, value_double(v));
break;
}
case VALUE_TYPE_STRING: {
ret = wbuffer_write_string(wbuffer, value_str(v));
break;
}
case VALUE_TYPE_WSTRING: {
char* str = tk_utf8_dup_wstr(value_wstr(v));
ret = wbuffer_write_string(wbuffer, str);
TKMEM_FREE(str);
break;
}
default: {
wbuffer_skip(wbuffer, -1);
ret = RET_NOT_IMPL;
}
}
return ret;
}
bool_t wbuffer_has_room(wbuffer_t* wbuffer, uint32_t size) {
return_value_if_fail(wbuffer != NULL && wbuffer->data != NULL, FALSE);
return (wbuffer->cursor + size) <= wbuffer->capacity;
}
ret_t wbuffer_write_string(wbuffer_t* wbuffer, const char* data) {
return_value_if_fail(data != NULL, RET_BAD_PARAMS);
return wbuffer_write_binary(wbuffer, data, strlen(data) + 1);
}
rbuffer_t* rbuffer_init(rbuffer_t* rbuffer, const void* data, uint32_t capacity) {
return_value_if_fail(rbuffer != NULL && data != NULL, NULL);
rbuffer->data = (const uint8_t*)data;
rbuffer->cursor = 0;
rbuffer->capacity = capacity;
return rbuffer;
}
bool_t rbuffer_has_more(rbuffer_t* rbuffer) {
return_value_if_fail(rbuffer != NULL, FALSE);
return rbuffer->cursor < rbuffer->capacity;
}
ret_t rbuffer_rewind(rbuffer_t* rbuffer) {
return_value_if_fail(rbuffer != NULL, RET_BAD_PARAMS);
rbuffer->cursor = 0;
return RET_OK;
}
ret_t rbuffer_skip(rbuffer_t* rbuffer, int32_t offset) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL, RET_BAD_PARAMS);
return_value_if_fail(((int32_t)(rbuffer->cursor) + offset) >= 0, RET_BAD_PARAMS);
return_value_if_fail(((int32_t)(rbuffer->cursor) + offset) <= rbuffer->capacity, RET_BAD_PARAMS);
rbuffer->cursor += offset;
return RET_OK;
}
ret_t rbuffer_read_uint8(rbuffer_t* rbuffer, uint8_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
*value = rbuffer->data[rbuffer->cursor++];
return RET_OK;
}
ret_t rbuffer_read_uint16(rbuffer_t* rbuffer, uint16_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_uint32(rbuffer_t* rbuffer, uint32_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_uint64(rbuffer_t* rbuffer, uint64_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_int8(rbuffer_t* rbuffer, int8_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
*value = rbuffer->data[rbuffer->cursor++];
return RET_OK;
}
ret_t rbuffer_read_int16(rbuffer_t* rbuffer, int16_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_int32(rbuffer_t* rbuffer, int32_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_int64(rbuffer_t* rbuffer, int64_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_float(rbuffer_t* rbuffer, float* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_double(rbuffer_t* rbuffer, double* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
rbuffer->cursor += sizeof(*value);
return RET_OK;
}
ret_t rbuffer_read_binary(rbuffer_t* rbuffer, void* data, uint32_t size) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && data != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + size) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(data, rbuffer->data + rbuffer->cursor, size);
rbuffer->cursor += size;
return RET_OK;
}
ret_t rbuffer_read_value(rbuffer_t* rbuffer, value_t* v) {
ret_t ret = RET_FAIL;
uint8_t type = 0;
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && v != NULL, RET_BAD_PARAMS);
ret = rbuffer_read_uint8(rbuffer, &type);
return_value_if_fail(ret == RET_OK, ret);
switch (type) {
case VALUE_TYPE_BOOL: {
uint8_t value = 0;
ret = rbuffer_read_uint8(rbuffer, &value);
value_set_bool(v, value);
break;
}
case VALUE_TYPE_UINT8: {
uint8_t value = 0;
ret = rbuffer_read_uint8(rbuffer, &value);
value_set_uint8(v, value);
break;
}
case VALUE_TYPE_INT8: {
int8_t value = 0;
ret = rbuffer_read_int8(rbuffer, &value);
value_set_int8(v, value);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t value = 0;
ret = rbuffer_read_uint16(rbuffer, &value);
value_set_uint16(v, value);
break;
}
case VALUE_TYPE_INT16: {
int16_t value = 0;
ret = rbuffer_read_int16(rbuffer, &value);
value_set_int16(v, value);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t value = 0;
ret = rbuffer_read_uint32(rbuffer, &value);
value_set_uint32(v, value);
break;
}
case VALUE_TYPE_INT32: {
int32_t value = 0;
ret = rbuffer_read_int32(rbuffer, &value);
value_set_int32(v, value);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t value = 0;
ret = rbuffer_read_uint64(rbuffer, &value);
value_set_uint64(v, value);
break;
}
case VALUE_TYPE_INT64: {
int64_t value = 0;
ret = rbuffer_read_int64(rbuffer, &value);
value_set_int64(v, value);
break;
}
case VALUE_TYPE_FLOAT32: {
float value = 0;
ret = rbuffer_read_float(rbuffer, &value);
value_set_float32(v, value);
break;
}
case VALUE_TYPE_FLOAT: {
double value = 0;
ret = rbuffer_read_double(rbuffer, &value);
value_set_float(v, value);
break;
}
case VALUE_TYPE_DOUBLE: {
double value = 0;
ret = rbuffer_read_double(rbuffer, &value);
value_set_double(v, value);
break;
}
case VALUE_TYPE_STRING: {
const char* value = NULL;
ret = rbuffer_read_string(rbuffer, &value);
value_set_str(v, value);
break;
}
default: {
rbuffer_skip(rbuffer, -1);
ret = RET_NOT_IMPL;
}
}
return ret;
}
ret_t rbuffer_read_string(rbuffer_t* rbuffer, const char** str) {
uint32_t len = 0;
uint32_t max_count = 0;
const char* start = NULL;
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && str != NULL, RET_BAD_PARAMS);
start = (const char*)rbuffer->data + rbuffer->cursor;
max_count = rbuffer->capacity - rbuffer->cursor;
len = tk_strnlen(start, max_count);
if (rbuffer->cursor + len == rbuffer->capacity) {
*str = NULL;
return RET_FAIL;
}
*str = (const char*)start;
rbuffer->cursor += len + 1;
return RET_OK;
}
ret_t rbuffer_peek_uint8(rbuffer_t* rbuffer, uint8_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
*value = rbuffer->data[rbuffer->cursor];
return RET_OK;
}
ret_t rbuffer_peek_uint16(rbuffer_t* rbuffer, uint16_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
return RET_OK;
}
ret_t rbuffer_peek_uint32(rbuffer_t* rbuffer, uint32_t* value) {
return_value_if_fail(rbuffer != NULL && rbuffer->data != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail((rbuffer->cursor + sizeof(*value)) <= rbuffer->capacity, RET_BAD_PARAMS);
memcpy(value, rbuffer->data + rbuffer->cursor, sizeof(*value));
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_http.c
|
/**
* File: data_reader.c
* Author: AWTK Develop Team
* Brief: data_reader
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License http for more details.
*
*/
/**
* History:
* ================================================================
* 2023-12-22 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/url.h"
#include "tkc/utils.h"
#include "tkc/buffer.h"
#include "tkc/data_reader_http.h"
#include "streams/stream_factory.h"
typedef struct _data_reader_http_t {
data_reader_t data_reader;
uint64_t size;
uint8_t* data;
} data_reader_http_t;
static const char* url_get_path(const char* url) {
const char* p = NULL;
return_value_if_fail(url != NULL, NULL);
p = strstr(url, "://");
if (p != NULL) {
p += 3;
p = strchr(p, '/');
if (p == NULL) {
p = "/";
}
}
return p;
}
static uint8_t* data_reader_http_get_chunked_data(uint8_t* data, uint32_t* size) {
uint8_t* p = data;
uint8_t* q = data;
uint32_t chunk_size = 0;
return_value_if_fail(data != NULL && size != NULL, NULL);
while (TRUE) {
if (p[0] == '\r' && p[1] == '\n') {
break;
}
p++;
}
chunk_size = tk_strtol((const char*)q, NULL, 16);
p += 2;
if (chunk_size == 0) {
*size = 0;
return NULL;
}
*size = chunk_size;
return p;
}
static ret_t data_reader_http_decode_chuncked_data(data_reader_http_t* http, wbuffer_t* wb) {
uint32_t size = 0;
uint8_t* src = NULL;
uint8_t* dst = NULL;
return_value_if_fail(http != NULL && wb != NULL, RET_BAD_PARAMS);
http->data = TKMEM_ALLOC(wb->cursor + 1);
return_value_if_fail(http->data != NULL, RET_OOM);
src = wb->data;
dst = http->data;
while ((src = data_reader_http_get_chunked_data(src, &size)) != NULL) {
memcpy(dst, src, size);
dst += size;
src += size + 2;
}
http->size = dst - http->data;
http->data[http->size] = '\0';
log_debug("%s\n", http->data);
return RET_OK;
}
static ret_t data_reader_http_get(data_reader_http_t* http, const char* url) {
char buff[1024];
int32_t nr = 0;
url_t* aurl = NULL;
const char* p = NULL;
tk_iostream_t* io = NULL;
return_value_if_fail(url != NULL && http != NULL, RET_BAD_PARAMS);
aurl = url_create(url);
return_value_if_fail(aurl != NULL, RET_BAD_PARAMS);
io = tk_stream_factory_create_iostream(url);
return_value_if_fail(io != NULL, RET_BAD_PARAMS);
tk_snprintf(buff, sizeof(buff) - 1, "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n",
url_get_path(url), aurl->host);
nr = tk_iostream_write(io, buff, strlen(buff));
url_destroy(aurl);
goto_error_if_fail(nr > 0);
nr = tk_iostream_read(io, buff, sizeof(buff) - 1);
if (nr > 0) {
buff[nr] = '\0';
p = strstr(buff, "Content-Length:");
if (p != NULL) {
p += strlen("Content-Length:");
while (*p == ' ') {
p++;
}
http->size = tk_atoi(p);
goto_error_if_fail(http->size > 0);
http->data = TKMEM_ALLOC(http->size + 1);
goto_error_if_fail(http->data != NULL);
p = strstr(buff, "\r\n\r\n");
goto_error_if_fail(p != NULL);
p += 4;
nr = nr - (p - buff);
memcpy(http->data, p, nr);
if (http->size > nr) {
nr = tk_iostream_read_len(io, http->data + nr, http->size - nr, TK_ISTREAM_DEFAULT_TIMEOUT);
goto_error_if_fail(nr > 0);
}
http->data[http->size] = '\0';
} else if (strstr(buff, "Transfer-Encoding: chunked") != NULL) {
wbuffer_t wb;
wbuffer_init_extendable(&wb);
wbuffer_extend_capacity(&wb, 10240);
p = strstr(buff, "\r\n\r\n");
goto_error_if_fail(p != NULL);
p += 4;
nr = nr - (p - buff);
wbuffer_write_binary(&wb, p, nr);
while ((nr = tk_iostream_read(io, buff, sizeof(buff) - 1)) > 0) {
if (wbuffer_write_binary(&wb, buff, nr) != RET_OK) {
wbuffer_deinit(&wb);
return RET_OOM;
}
}
data_reader_http_decode_chuncked_data(http, &wb);
wbuffer_deinit(&wb);
} else {
goto error;
}
}
TK_OBJECT_UNREF(io);
return RET_OK;
error:
TK_OBJECT_UNREF(io);
return RET_FAIL;
}
static int32_t data_reader_http_read(data_reader_t* reader, uint64_t offset, void* data,
uint32_t size) {
data_reader_http_t* http = (data_reader_http_t*)reader;
return_value_if_fail(http != NULL && data != NULL, 0);
return_value_if_fail(offset <= http->size, 0);
size = tk_min(size, http->size - offset);
memcpy(data, http->data + offset, size);
return size;
}
static uint64_t data_reader_http_get_size(data_reader_t* reader) {
data_reader_http_t* http = (data_reader_http_t*)reader;
return_value_if_fail(http != NULL, 0);
return http->size;
}
static ret_t data_reader_http_destroy(data_reader_t* reader) {
data_reader_http_t* http = (data_reader_http_t*)reader;
TKMEM_FREE(http->data);
TKMEM_FREE(http);
return RET_OK;
}
static const data_reader_vtable_t s_data_reader_http_vtable = {
.read = data_reader_http_read,
.get_size = data_reader_http_get_size,
.destroy = data_reader_http_destroy,
};
data_reader_t* data_reader_http_create(const char* url) {
data_reader_http_t* http = NULL;
return_value_if_fail(url != NULL, NULL);
http = TKMEM_ZALLOC(data_reader_http_t);
return_value_if_fail(http != NULL, NULL);
if (data_reader_http_get(http, url) != RET_OK) {
TKMEM_FREE(http->data);
TKMEM_FREE(http);
return NULL;
}
http->data_reader.vt = &s_data_reader_http_vtable;
return (data_reader_t*)http;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/socket_helper.c
|
/**
* File: socket_helper.h
* Author: AWTK Develop Team
* Brief: socket helper functions
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-05 Li XianJing <[email protected]> created
*
*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif /*WIN32_LEAN_AND_MEAN*/
#include "tkc/mem.h"
#include "tkc/socket_helper.h"
#ifdef WITH_SOCKET
#if defined(LINUX) || defined(MACOS)
#include <signal.h>
static ret_t tk_ignore_sig_pipe(void) {
signal(SIGPIPE, SIG_IGN);
return RET_OK;
}
#else
#define tk_ignore_sig_pipe()
#endif /*LINUX*/
#ifdef WIN32
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32")
ret_t tk_socket_init() {
int iResult;
WSADATA wsaData;
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
log_debug("WSAStartup failed: %d\n", iResult);
return RET_FAIL;
}
tk_ignore_sig_pipe();
return RET_OK;
}
ret_t tk_socket_deinit() {
WSACleanup();
return RET_OK;
}
ret_t tk_socket_close(int sock) {
closesocket(sock);
return RET_OK;
}
#else
ret_t tk_socket_init() {
tk_ignore_sig_pipe();
return RET_OK;
}
ret_t tk_socket_deinit() {
return RET_OK;
}
ret_t tk_socket_close(int sock) {
#ifdef AWORKS
closesocket(sock);
#else
close(sock);
#endif
return RET_OK;
}
#endif /*WIN32*/
ret_t tk_socket_bind_ex(int sock, const char* ip, int port) {
struct sockaddr_in s;
return_value_if_fail(sock >= 0 && port >= 0, RET_BAD_PARAMS);
memset(&s, 0, sizeof(s));
if (ip != NULL) {
tk_socket_resolve(ip, port, &s);
} else {
s.sin_family = AF_INET;
s.sin_port = htons(port);
s.sin_addr.s_addr = htonl(INADDR_ANY);
}
if (bind(sock, (struct sockaddr*)&s, sizeof(s)) < 0) {
log_debug("bind error\n");
return RET_FAIL;
}
return RET_OK;
}
ret_t tk_socket_bind(int sock, int port) {
return tk_socket_bind_ex(sock, NULL, port);
}
int tk_socket_get_port(int sock) {
struct sockaddr_in serv_addr;
socklen_t serv_addr_len = sizeof(serv_addr);
if (getsockname(sock, (struct sockaddr *)&serv_addr, &serv_addr_len) >= 0) {
return ntohs(serv_addr.sin_port);
}
return -1;
}
int tk_tcp_listen(int port) {
int sock;
int on = 1;
if ((sock = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
perror("socket error\n");
return -1;
}
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)) < 0) {
log_debug("setsockopt error\n");
return -1;
}
return_value_if_fail(tk_socket_bind(sock, port) == RET_OK, -1);
if (listen(sock, 5) < 0) {
log_debug("listen error\n");
return -1;
}
if (port == 0) {
struct sockaddr_in serv_addr;
socklen_t serv_addr_len = sizeof(serv_addr);
if (getsockname(sock, (struct sockaddr *)&serv_addr, &serv_addr_len) >= 0) {
log_debug("port is 0, system auto allocted port is %d\n", ntohs(serv_addr.sin_port));
}
}
return (sock);
}
int tk_udp_listen(int port) {
int sock;
int on = 1;
struct sockaddr_in s;
if ((sock = (int)socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket error\n");
return -1;
}
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)) < 0) {
log_debug("setsockopt error\n");
return -1;
}
memset(&s, 0, sizeof(s));
s.sin_family = AF_INET;
s.sin_port = htons(port);
s.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sock, (struct sockaddr*)&s, sizeof(s)) < 0) {
log_debug("bind error\n");
return -1;
}
return (sock);
}
#define h_addr h_addr_list[0]
struct sockaddr* tk_socket_resolve(const char* host, int port, struct sockaddr_in* addr) {
struct hostent* h = NULL;
return_value_if_fail(host != NULL && addr != NULL, NULL);
h = gethostbyname(host);
return_value_if_fail(h != NULL, NULL);
memset(addr, 0x00, sizeof(*addr));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
return_value_if_fail(h->h_addrtype == AF_INET, NULL);
memcpy(&(addr->sin_addr.s_addr), h->h_addr, h->h_length);
return (struct sockaddr*)addr;
}
bool_t tk_tcp_is_port_in_use(int port) {
int sock = 0;
struct sockaddr_in s_in;
const char* host = "0.0.0.0";
struct sockaddr* addr = tk_socket_resolve(host, port, &s_in);
return_value_if_fail(addr != NULL, -1);
if ((sock = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
return FALSE;
}
if (connect(sock, addr, sizeof(s_in)) < 0) {
tk_socket_close(sock);
return FALSE;
} else {
tk_socket_close(sock);
return TRUE;
}
}
int tk_tcp_connect(const char* host, int port) {
int sock = 0;
struct sockaddr_in s_in;
struct sockaddr* addr = tk_socket_resolve(host, port, &s_in);
return_value_if_fail(addr != NULL, -1);
if ((sock = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
log_debug("socket for %s %d failed\n", host, port);
return -1;
}
if (connect(sock, addr, sizeof(s_in)) < 0) {
log_debug("connect %s %d failed\n", host, port);
tk_socket_close(sock);
return -1;
}
return sock;
}
int tk_tcp_connect_ex(const char* host, int port, int timeout, void* opts) {
int ret = 0;
int sock = 0;
int sockfd = -1;
int error = 0, wsaError = 0;
socklen_t len;
fd_set rset, wset;
struct sockaddr_in s_in;
struct timeval tv = {0, 0};
struct sockaddr* addr = socket_resolve(host, port, &s_in);
return_value_if_fail(addr != NULL, -1);
return_value_if_fail(opts == NULL, -1);
if (timeout <= 0) {
return tk_tcp_connect(host, port);
}
if ((sock = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
log_debug("socket error\n");
return -1;
}
tk_socket_set_blocking(sock, FALSE);
ret = connect(sock, addr, sizeof(s_in));
#ifdef _WIN32
if (ret < 0) {
wsaError = WSAGetLastError();
}
if (wsaError != WSAEWOULDBLOCK && wsaError != WSAEINPROGRESS) {
#else
(void)wsaError;
if (ret < 0 && errno != EINPROGRESS) {
#endif
log_debug("connect error\n");
goto done;
} else if (ret == 0) {
sockfd = sock;
goto done;
}
FD_ZERO(&rset);
FD_ZERO(&wset);
FD_SET(sock, &rset);
FD_SET(sock, &wset);
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
ret = select(sock + 1, &rset, &wset, NULL, timeout == 0xFFFFFFFF ? NULL : &tv);
if (ret <= 0) {
/* Timeout or fail */
goto done;
}
if (FD_ISSET(sock, &rset) || FD_ISSET(sock, &wset)) {
len = sizeof(error);
ret = getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
if (ret != 0 || error != 0) {
#ifndef _WIN32
errno = ECONNREFUSED;
#endif
goto done;
} else {
sockfd = sock;
}
} else {
goto done;
}
done:
tk_socket_set_blocking(sock, TRUE);
if (sockfd == -1) {
tk_socket_close(sock);
}
return sockfd;
}
int tk_udp_connect(const char* host, int port) {
int sock = 0;
struct sockaddr_in s_in;
struct sockaddr* addr = tk_socket_resolve(host, port, &s_in);
return_value_if_fail(addr != NULL, -1);
if ((sock = (int)socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
log_debug("socket error\n");
return -1;
}
if (connect(sock, addr, sizeof(s_in)) < 0) {
log_debug("connect error\n");
tk_socket_close(sock);
return -1;
}
return sock;
}
int tk_tcp_accept(int sock) {
int so;
struct sockaddr_in s;
socklen_t namelen;
namelen = sizeof(s);
memset((char*)&s, 0, namelen);
if ((so = (int)accept(sock, (struct sockaddr*)&s, &namelen)) < 0) {
return -1;
}
return so;
}
ret_t tk_socket_set_blocking(int sock, bool_t blocking) {
return_value_if_fail(sock >= 0, RET_BAD_PARAMS);
#ifdef _WIN32
unsigned long mode = blocking ? 0 : 1;
return (ioctlsocket(sock, FIONBIO, &mode) == 0) ? RET_OK : RET_FAIL;
#else
int flags = fcntl(sock, F_GETFL, 0);
if (flags == -1) return RET_FAIL;
flags = blocking ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK);
return (fcntl(sock, F_SETFL, flags) == 0) ? RET_OK : RET_FAIL;
#endif
}
ret_t tk_socket_wait_for_data(int sock, uint32_t timeout_ms) {
fd_set fdsr;
int ret = 0;
struct timeval tv = {0, 0};
FD_ZERO(&fdsr);
FD_SET(sock, &fdsr);
tv.tv_sec = timeout_ms / 1000;
tv.tv_usec = (timeout_ms % 1000) * 1000;
FD_SET(sock, &fdsr);
ret = select(sock + 1, &fdsr, NULL, NULL, &tv);
return ret > 0 && FD_ISSET(sock, &fdsr) ? RET_OK : RET_TIMEOUT;
}
bool_t tk_socket_last_io_has_error(void) {
#ifndef WIN32
int eno = errno;
return eno != EAGAIN && eno != 0;
#else
int eno = GetLastError();
return eno != 1237 && eno != 0;
#endif /*WIN32*/
}
uint32_t tk_socket_get_client_ip(int sockfd) {
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
if (getpeername(sockfd, (struct sockaddr*)&addr, &addrLen) == 0) {
return addr.sin_addr.s_addr;
}
return 0;
}
uint32_t tk_socket_get_self_ip(int sockfd) {
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
if (getsockname(sockfd, (struct sockaddr*)&addr, &addrLen) == 0) {
return addr.sin_addr.s_addr;
}
return 0;
}
const char* tk_socket_get_client_ip_str(int sockfd, char* ip, int len) {
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
return_value_if_fail(ip != NULL && len > 0, NULL);
if (getpeername(sockfd, (struct sockaddr*)&addr, &addrLen) == 0) {
return inet_ntop(AF_INET, &(addr.sin_addr), ip, len);
}
return NULL;
}
const char* tk_socket_get_self_ip_str(int sockfd, char* ip, int len) {
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
return_value_if_fail(ip != NULL && len > 0, NULL);
if (getsockname(sockfd, (struct sockaddr*)&addr, &addrLen) == 0) {
return inet_ntop(AF_INET, &(addr.sin_addr), ip, len);
}
return NULL;
}
int tk_udp_socket(void) {
return (int)socket(AF_INET, SOCK_DGRAM, 0);
}
int32_t tk_socket_send(int sock, const void* buffer, uint32_t size, int flags) {
return send(sock, buffer, size, flags);
}
int32_t tk_socket_sendto(int sock, const void* buffer, uint32_t size, int flags,
const struct sockaddr* dest_addr, uint32_t dest_len) {
return_value_if_fail(buffer != NULL, 0);
return_value_if_fail(dest_addr != NULL, 0);
return sendto(sock, buffer, size, flags, dest_addr, (socklen_t)dest_len);
}
int32_t tk_socket_recv(int sock, void* buffer, uint32_t size, int flags) {
return recv(sock, buffer, size, flags);
}
int32_t tk_socket_recvfrom(int sock, void* buffer, uint32_t size, int flags,
struct sockaddr* dest_addr, uint32_t* dest_len) {
return_value_if_fail(buffer != NULL, 0);
return_value_if_fail(dest_addr != NULL && dest_len != NULL, 0);
socklen_t len = *dest_len;
int32_t ret = recvfrom(sock, buffer, size, flags, dest_addr, &len);
*dest_len = len;
return ret;
}
#else
ret_t tk_socket_init(void) {
return RET_OK;
}
ret_t tk_socket_deinit(void) {
return RET_OK;
}
#endif /*WITH_SOCKET*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_oom.h
|
/**
* File: mem_allocator_oom.h
* Author: AWTK Develop Team
* Brief: mem_allocator_oom
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_OOM_H
#define TK_MEM_ALLOCATOR_OOM_H
#include "tkc/mem_allocator.h"
BEGIN_C_DECLS
/**
* @class mem_allocator_oom_t
* @parent mem_allocator_t
*
* 对现有的allocator进行包装，如果分配内存失败，调用预先设置的回调函数释放内存，然后再重试。
*
*/
typedef struct _mem_allocator_oom_t {
mem_allocator_t allocator;
mem_allocator_t* impl;
} mem_allocator_oom_t;
#define MEM_ALLOCATOR_OOM(allocator) ((mem_allocator_oom_t*)(allocator))
#define TRY_MAX_TIMES 5
static void* s_on_out_of_memory_ctx;
static tk_mem_on_out_of_memory_t s_on_out_of_memory;
static ret_t tk_mem_on_out_of_memory(uint32_t tried_times, uint32_t need_size, const char* func,
uint32_t line) {
log_debug("oom %s:%u times=%u size=%u\n", func, line, tried_times, need_size);
if (s_on_out_of_memory != NULL) {
return s_on_out_of_memory(s_on_out_of_memory_ctx, tried_times, need_size);
}
return RET_NOT_IMPL;
}
ret_t tk_mem_set_on_out_of_memory(tk_mem_on_out_of_memory_t on_out_of_memory, void* ctx) {
s_on_out_of_memory = on_out_of_memory;
s_on_out_of_memory_ctx = ctx;
return RET_OK;
}
static inline void* mem_allocator_oom_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
void* addr = NULL;
uint32_t tried_times = 0;
mem_allocator_t* impl = MEM_ALLOCATOR_OOM(allocator)->impl;
do {
/*用于测试OOM，正常情况不会分配4G大小的内存块，用它做测试是安全的*/
if (size == 0xffffffff) {
addr = NULL;
} else {
addr = mem_allocator_alloc(impl, size, func, line);
}
if (addr != NULL) {
break;
}
tk_mem_on_out_of_memory(++tried_times, size, func, line);
} while (tried_times < TRY_MAX_TIMES);
return addr;
}
static inline void* mem_allocator_oom_realloc(mem_allocator_t* allocator, void* ptr, uint32_t size,
const char* func, uint32_t line) {
void* addr = NULL;
uint32_t tried_times = 0;
mem_allocator_t* impl = MEM_ALLOCATOR_OOM(allocator)->impl;
do {
addr = mem_allocator_realloc(impl, ptr, size, func, line);
if (addr != NULL) {
break;
}
tk_mem_on_out_of_memory(++tried_times, size, func, line);
} while (tried_times < TRY_MAX_TIMES);
return addr;
}
static inline void mem_allocator_oom_free(mem_allocator_t* allocator, void* ptr) {
mem_allocator_t* impl = MEM_ALLOCATOR_OOM(allocator)->impl;
if (ptr != NULL) {
mem_allocator_free(impl, ptr);
}
}
static inline ret_t mem_allocator_oom_dump(mem_allocator_t* allocator) {
mem_allocator_t* impl = MEM_ALLOCATOR_OOM(allocator)->impl;
mem_allocator_dump(impl);
return RET_OK;
}
static inline ret_t mem_allocator_oom_destroy(mem_allocator_t* allocator) {
mem_allocator_t* impl = MEM_ALLOCATOR_OOM(allocator)->impl;
mem_allocator_destroy(impl);
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_oom_vtable = {
.alloc = mem_allocator_oom_alloc,
.realloc = mem_allocator_oom_realloc,
.free = mem_allocator_oom_free,
.dump = mem_allocator_oom_dump,
.destroy = mem_allocator_oom_destroy};
static inline mem_allocator_t* mem_allocator_oom_init(mem_allocator_oom_t* oom,
mem_allocator_t* impl) {
mem_allocator_t* allocator = MEM_ALLOCATOR(oom);
return_value_if_fail(impl != NULL && oom != NULL, NULL);
memset(oom, 0x00, sizeof(*oom));
allocator->vt = &s_mem_allocator_oom_vtable;
oom->impl = impl;
return allocator;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_OOM_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/easing.c
|
/**
* File: easing.c
* Author: AWTK Develop Team
* Brief: easing functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-18 Li XianJing <[email protected]> created, adapted from
* https://github.com/tweenjs/tween.js.git
*
*/
#include "tkc/easing.h"
#include "tkc/mem.h"
#include "tkc/utils.h"
#define PI 3.1415926
#include "tkc/easing.h"
static float_t easing_linear(float_t k) {
return k;
}
static float_t easing_quadratic_in(float_t k) {
return k * k;
}
static float_t easing_quadratic_out(float_t k) {
return k * (2 - k);
}
static float_t easing_quadratic_inout(float_t k) {
if ((k *= 2) < 1) {
return 0.5f * k * k;
}
k -= 1;
return -0.5f * (k * (k - 2) - 1);
}
static float_t easing_cubic_in(float_t k) {
return k * k * k;
}
static float_t easing_cubic_out(float_t k) {
k -= 1;
return k * k * k + 1;
}
static float_t easing_sin_in(float_t k) {
if ((k *= 2) < 1) {
return 0.5f * k * k * k;
}
k -= 2;
return 0.5f * ((k)*k * k + 2);
}
static float_t easing_sin_out(float_t k) {
return 1 - (float_t)cos((float_t)(k * (float_t)PI / 2));
}
static float_t easing_sin_inout(float_t k) {
return (float_t)sin((float_t)(k * (float_t)PI / 2));
}
static float_t easing_pow_in(float_t k) {
return k == 0 ? 0 : pow(1024, k - 1);
}
static float_t easing_pow_out(float_t k) {
return k == 1 ? 1 : 1 - pow(2, -10 * k);
}
static float_t easing_pow_inout(float_t k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
if ((k *= 2) < 1) {
return 0.5 * pow(1024, k - 1);
}
return 0.5 * (-pow(2, -10 * (k - 1)) + 2);
}
static float_t easing_circular_in(float_t k) {
return 1 - sqrt(1 - k * k);
}
static float_t easing_circular_out(float_t k) {
k -= 1;
return sqrt(1 - (k * k));
}
static float_t easing_circular_inout(float_t k) {
if ((k *= 2) < 1) {
return -0.5 * (sqrt(1 - k * k) - 1);
}
k -= 2;
return 0.5 * (sqrt(1 - k * k) + 1);
}
static float_t easing_elastic_in(float_t k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
return -pow(2, 10 * (k - 1)) * (float_t)sin((float_t)((k - 1.1f) * 5 * (float_t)PI));
}
static float_t easing_elastic_out(float_t k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
return pow(2, -10 * k) * (float_t)sin((float_t)((k - 0.1f) * 5 * (float_t)PI)) + 1;
}
static float_t easing_elastic_inout(float_t k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
k *= 2;
if (k < 1) {
return -0.5f * pow(2, 10 * (k - 1)) * sin((float_t)((k - 1.1f) * 5 * (float_t)PI));
}
return 0.5f * pow(2, -10 * (k - 1)) * (float_t)sin((float_t)((k - 1.1f) * 5 * (float_t)PI)) + 1;
}
static float_t easing_back_in(float_t k) {
float_t s = 1.70158f;
return k * k * ((s + 1) * k - s);
}
static float_t easing_back_out(float_t k) {
float_t s = 1.70158f;
k -= 1;
return k * k * ((s + 1) * k + s) + 1;
}
static float_t easing_back_inout(float_t k) {
float_t s = 1.70158f * 1.525f;
if ((k *= 2) < 1) {
return 0.5f * (k * k * ((s + 1) * k - s));
}
k -= 2;
return 0.5f * ((k)*k * ((s + 1) * k + s) + 2);
}
static float_t easing_bounce_out(float_t k);
static float_t easing_bounce_in(float_t k) {
return 1 - easing_bounce_out(1 - k);
}
static float_t easing_bounce_out(float_t k) {
if (k < (1 / 2.75f)) {
return 7.5625f * k * k;
} else if (k < (2 / 2.75f)) {
k -= (1.5f / 2.75f);
return 7.5625f * (k)*k + 0.75f;
} else if (k < (2.5 / 2.75)) {
k -= (2.25f / 2.75f);
return 7.5625f * (k)*k + 0.9375f;
} else {
k -= (2.625f / 2.75f);
return 7.5625f * (k)*k + 0.984375f;
}
}
static float_t easing_bounce_inout(float_t k) {
if (k < 0.5f) {
return easing_bounce_in(k * 2) * 0.5f;
}
return easing_bounce_out(k * 2 - 1) * 0.5f + 0.5f;
}
static const easing_func_t s_easing_funcs[] = {
easing_linear, easing_quadratic_in, easing_quadratic_out, easing_quadratic_inout,
easing_cubic_in, easing_cubic_out, easing_sin_in, easing_sin_out,
easing_sin_inout, easing_pow_in, easing_pow_out, easing_pow_inout,
easing_circular_in, easing_circular_out, easing_circular_inout, easing_elastic_in,
easing_elastic_out, easing_elastic_inout, easing_back_in, easing_back_out,
easing_back_inout, easing_bounce_in, easing_bounce_out, easing_bounce_inout};
static darray_t* s_easing_name_func_darray = NULL;
darray_t* easing_name_func_darray() {
return s_easing_name_func_darray;
}
ret_t easing_name_func_destroy(void* data) {
easing_name_func_t* easing_name_func = (easing_name_func_t*)data;
if (easing_name_func != NULL && easing_name_func->type_name_value != NULL) {
TKMEM_FREE(easing_name_func->type_name_value->name);
TKMEM_FREE(easing_name_func->type_name_value);
TKMEM_FREE(easing_name_func);
}
return RET_OK;
}
int easing_name_func_compare(const void* a, const void* b) {
easing_name_func_t* easing_name_func_a = (easing_name_func_t*)a;
char* type_name = (char*)b;
return strcmp(easing_name_func_a->type_name_value->name, type_name);
}
ret_t easing_init(void) {
s_easing_name_func_darray = darray_create(0, easing_name_func_destroy, easing_name_func_compare);
return RET_OK;
}
ret_t easing_deinit(void) {
darray_destroy(s_easing_name_func_darray);
return RET_OK;
}
easing_func_t easing_get(easing_type_t type) {
if ((int)type >= EASING_LINEAR && type < EASING_FUNC_NR) {
return s_easing_funcs[type];
} else if ((int)type > EASING_FUNC_NR &&
(int)type <= EASING_FUNC_NR + s_easing_name_func_darray->size) {
easing_name_func_t* easing_name_func =
darray_get(s_easing_name_func_darray, type - EASING_FUNC_NR - 1);
return easing_name_func->easing_func;
} else {
return s_easing_funcs[EASING_LINEAR];
}
}
uint32_t easing_register(const char* type_name, easing_func_t easing_func) {
easing_name_func_t* easing_name_func = TKMEM_ZALLOC(easing_name_func_t);
ENSURE(easing_name_func);
easing_name_func->type_name_value = TKMEM_ZALLOC(key_type_value_t);
ENSURE(easing_name_func->type_name_value);
easing_name_func->type_name_value->name =
tk_str_copy(easing_name_func->type_name_value->name, type_name);
easing_name_func->type_name_value->value = EASING_FUNC_NR + s_easing_name_func_darray->size + 1;
easing_name_func->easing_func = easing_func;
darray_push(s_easing_name_func_darray, easing_name_func);
return EASING_FUNC_NR + s_easing_name_func_darray->size;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/endian.h
|
/**
* File: endian.h
* Author: AWTK Develop Team
* Brief: endian related functions.
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-14 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ENDIAN_H
#define TK_ENDIAN_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class endian_t
* @annotation ["fake"]
*
* 字节顺序转换相关函数。
*
* 示例
*
* ```c
* uint16_t a = 0x1234;
* ENSURE(is_little_endian());
* ENSURE(int16_endian_invert(a) == 0x3412);
* ENSURE(int16_from_big_endian(a) == 0x3412);
* ENSURE(int16_to_big_endian(a) == 0x3412);
*
* int32_t b = 0x12345678;
* ENSURE(int32_endian_invert(b) == 0x78563412);
* ENSURE(int32_from_big_endian(b) == 0x78563412);
* ENSURE(int32_to_big_endian(b) == 0x78563412);
*
* int64_t c = 0x1234567890ABCDEF;
* ENSURE(int64_endian_invert(c) == 0xEFCDAB9078563412);
* ENSURE(int64_from_big_endian(c) == 0xEFCDAB9078563412);
* ENSURE(int64_to_big_endian(c) == 0xEFCDAB9078563412);
*
* float f1 = 1.23;
* float f2 = float_endian_invert(f1);
* ENSURE(float_from_big_endian(f2) == f1);
* float f3 = float_from_big_endian(f2);
* ENSURE(float_to_big_endian(f3) == f2);
*
* double d1 = 1.2345678;
* double d2 = double_endian_invert(d1);
* ENSURE(double_from_big_endian(d2) == d1);
* double d3 = double_from_big_endian(d2);
* ENSURE(double_to_big_endian(d3) == d2);
* ```
*/
/**
* @method swap_uint8
* @annotation ["static", "private"]
* @export none
* 交换两个uint8_t的值。
* @param {uint8_t*} p1 数1.
* @param {uint8_t*} p2 数2.
*
* @return {void} 无。
*/
static inline void swap_uint8(uint8_t* p1, uint8_t* p2) {
uint8_t c = *p1;
*p1 = *p2;
*p2 = c;
}
/**
* @method is_little_endian
* @annotation ["static"]
* @export none
* 检查当前系统是否是小端模式。
*
* @return {bool_t} 返回TRUE表示是，否则表示不是。
*/
static inline bool_t is_little_endian(void) {
uint16_t val = 0x1122;
return *((uint8_t*)&val) == 0x22;
}
/**
* @method int16_endian_invert
* @annotation ["static"]
* @export none
* 16 整数大小端模式转换。
* @param {int16_t} value 输入数据。
*
* @return {int16_t} 返回转换后的数据。
*/
static inline int16_t int16_endian_invert(int16_t value) {
int16_t ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 1);
return ret;
}
/**
* @method int16_to_big_endian
* @annotation ["static"]
* @export none
* 16 整数转换为大端模式。
* @param {int16_t} value 输入数据。
*
* @return {int16_t} 返回转换后的数据。
*/
static inline int16_t int16_to_big_endian(int16_t value) {
return is_little_endian() ? int16_endian_invert(value) : value;
}
/**
* @method int16_from_big_endian
* @annotation ["static"]
* @export none
* 16 整数转换为小端模式。
* @param {int16_t} value 输入数据。
*
* @return {int16_t} 返回转换后的数据。
*/
static inline int16_t int16_from_big_endian(int16_t value) {
return is_little_endian() ? int16_endian_invert(value) : value;
}
/**
* @method uint16_endian_invert
* @annotation ["static"]
* @export none
* 16 无符号整数大小端模式转换。
* @param {uint16_t} value 输入数据。
*
* @return {uint16_t} 返回转换后的数据。
*/
static inline uint16_t uint16_endian_invert(uint16_t value) {
uint16_t ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 1);
return ret;
}
/**
* @method uint16_to_big_endian
* @annotation ["static"]
* @export none
* 16 无符号整数转换为大端模式。
* @param {uint16_t} value 输入数据。
*
* @return {uint16_t} 返回转换后的数据。
*/
static inline uint16_t uint16_to_big_endian(uint16_t value) {
return is_little_endian() ? uint16_endian_invert(value) : value;
}
/**
* @method uint16_from_big_endian
* @annotation ["static"]
* @export none
* 16 无符号整数转换为小端模式。
* @param {uint16_t} value 输入数据。
*
* @return {uint16_t} 返回转换后的数据。
*/
static inline uint16_t uint16_from_big_endian(uint16_t value) {
return is_little_endian() ? uint16_endian_invert(value) : value;
}
/**
* @method int32_endian_invert
* @annotation ["static"]
* @export none
* 32 整数大小端模式转换。
* @param {int32_t} value 输入数据。
*
* @return {int32_t} 返回转换后的数据。
*/
static inline int32_t int32_endian_invert(int32_t value) {
int32_t ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 3);
swap_uint8(p + 1, p + 2);
return ret;
}
/**
* @method int32_to_big_endian
* @annotation ["static"]
* @export none
* 32 整数转换为大端模式。
* @param {int32_t} value 输入数据。
*
* @return {int32_t} 返回转换后的数据。
*/
static inline int32_t int32_to_big_endian(int32_t value) {
return is_little_endian() ? int32_endian_invert(value) : value;
}
/**
* @method int32_from_big_endian
* @annotation ["static"]
* @export none
* 32 整数转换为小端模式。
* @param {int32_t} value 输入数据。
*
* @return {int32_t} 返回转换后的数据。
*/
static inline int32_t int32_from_big_endian(int32_t value) {
return is_little_endian() ? int32_endian_invert(value) : value;
}
/**
* @method uint32_endian_invert
* @annotation ["static"]
* @export none
* 32 无符号整数大小端模式转换。
* @param {uint32_t} value 输入数据。
*
* @return {uint32_t} 返回转换后的数据。
*/
static inline uint32_t uint32_endian_invert(uint32_t value) {
uint32_t ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 3);
swap_uint8(p + 1, p + 2);
return ret;
}
/**
* @method uint32_to_big_endian
* @annotation ["static"]
* @export none
* 32 无符号整数转换为大端模式。
* @param {uint32_t} value 输入数据。
*
* @return {uint32_t} 返回转换后的数据。
*/
static inline uint32_t uint32_to_big_endian(uint32_t value) {
return is_little_endian() ? uint32_endian_invert(value) : value;
}
/**
* @method uint32_from_big_endian
* @annotation ["static"]
* @export none
* 32 无符号整数转换为小端模式。
* @param {uint32_t} value 输入数据。
*
* @return {uint32_t} 返回转换后的数据。
*/
static inline uint32_t uint32_from_big_endian(uint32_t value) {
return is_little_endian() ? uint32_endian_invert(value) : value;
}
/**
* @method int64_endian_invert
* @annotation ["static"]
* @export none
* 64 整数大小端模式转换。
* @param {int64_t} value 输入数据。
*
* @return {int64_t} 返回转换后的数据。
*/
static inline int64_t int64_endian_invert(int64_t value) {
int64_t ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 7);
swap_uint8(p + 1, p + 6);
swap_uint8(p + 2, p + 5);
swap_uint8(p + 3, p + 4);
return ret;
}
/**
* @method int64_to_big_endian
* @annotation ["static"]
* @export none
* 64 整数转换为大端模式。
* @param {int64_t} value 输入数据。
*
* @return {int64_t} 返回转换后的数据。
*/
static inline int64_t int64_to_big_endian(int64_t value) {
return is_little_endian() ? int64_endian_invert(value) : value;
}
/**
* @method int64_from_big_endian
* @annotation ["static"]
* @export none
* 64 整数转换为小端模式。
* @param {int64_t} value 输入数据。
*
* @return {int64_t} 返回转换后的数据。
*/
static inline int64_t int64_from_big_endian(int64_t value) {
return is_little_endian() ? int64_endian_invert(value) : value;
}
/**
* @method uint64_endian_invert
* @annotation ["static"]
* @export none
* 64 无符号整数大小端模式转换。
* @param {uint64_t} value 输入数据。
*
* @return {uint64_t} 返回转换后的数据。
*/
static inline uint64_t uint64_endian_invert(uint64_t value) {
uint64_t ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 7);
swap_uint8(p + 1, p + 6);
swap_uint8(p + 2, p + 5);
swap_uint8(p + 3, p + 4);
return ret;
}
/**
* @method uint64_to_big_endian
* @annotation ["static"]
* @export none
* 64 无符号整数转换为大端模式。
* @param {uint64_t} value 输入数据。
*
* @return {uint64_t} 返回转换后的数据。
*/
static inline uint64_t uint64_to_big_endian(uint64_t value) {
return is_little_endian() ? uint64_endian_invert(value) : value;
}
/**
* @method uint64_from_big_endian
* @annotation ["static"]
* @export none
* 64 无符号整数转换为小端模式。
* @param {uint64_t} value 输入数据。
*
* @return {uint64_t} 返回转换后的数据。
*/
static inline uint64_t uint64_from_big_endian(uint64_t value) {
return is_little_endian() ? uint64_endian_invert(value) : value;
}
/**
* @method float_endian_invert
* @annotation ["static"]
* @export none
* float浮点数大小端模式转换。
* @param {float} value 输入数据。
*
* @return {float} 返回转换后的数据。
*/
static inline float float_endian_invert(float value) {
float ret = value;
uint8_t* p = (uint8_t*)&ret;
swap_uint8(p, p + 3);
swap_uint8(p + 1, p + 2);
return ret;
}
/**
* @method float_to_big_endian
* @annotation ["static"]
* @export none
* float浮点数转换为大端模式。
* @param {float} value 输入数据。
*
* @return {float} 返回转换后的数据。
*/
static inline float float_to_big_endian(float value) {
return is_little_endian() ? float_endian_invert(value) : value;
}
/**
* @method float_from_big_endian
* @annotation ["static"]
* @export none
* float浮点数转换为小端模式。
* @param {float} value 输入数据。
*
* @return {float} 返回转换后的数据。
*/
static inline float float_from_big_endian(float value) {
return is_little_endian() ? float_endian_invert(value) : value;
}
/**
* @method double_endian_invert
* @annotation ["static"]
* @export none
* double浮点数大小端模式转换。
* @param {double} value 输入数据。
*
* @return {double} 返回转换后的数据。
*/
static inline double double_endian_invert(double value) {
double ret = value;
uint8_t* p = (uint8_t*)&ret;
assert(sizeof(value) == 8);
swap_uint8(p, p + 7);
swap_uint8(p + 1, p + 6);
swap_uint8(p + 2, p + 5);
swap_uint8(p + 3, p + 4);
return ret;
}
/**
* @method double_to_big_endian
* @annotation ["static"]
* @export none
* double浮点数转换为大端模式。
* @param {double} value 输入数据。
*
* @return {double} 返回转换后的数据。
*/
static inline double double_to_big_endian(double value) {
return is_little_endian() ? double_endian_invert(value) : value;
}
/**
* @method double_from_big_endian
* @annotation ["static"]
* @export none
* double浮点数转换为小端模式。
* @param {double} value 输入数据。
*
* @return {double} 返回转换后的数据。
*/
static inline double double_from_big_endian(double value) {
return is_little_endian() ? double_endian_invert(value) : value;
}
END_C_DECLS
#endif /*TK_ENDIAN_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem.c
|
/**
* File: mem.c
* Author: AWTK Develop Team
* Brief: simple memory manager
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#include <stdarg.h>
#include "tkc/mem.h"
#include "tkc/time_now.h"
#include "tkc/mem_allocator_oom.h"
#include "tkc/mem_allocator_pool.h"
#if !defined(WITH_OS_MEM)
static mem_allocator_oom_t s_oom;
#ifdef ENABLE_MEM_LEAK_CHECK
#include "tkc/mem_allocator_debug.h"
static mem_allocator_debug_t s_debug;
#endif /*ENABLE_MEM_LEAK_CHECK*/
static mem_allocator_t* s_allocator = NULL;
#endif /*WITH_OS_MEM*/
#define MAX_BLOCK_SIZE 0xffff0000
#ifdef HAS_STD_MALLOC
#include "tkc/mem_allocator_std.h"
#ifdef ENABLE_MEM_LEAK_CHECK
#include "tkc/mem_allocator_lock.h"
static mem_allocator_lock_t s_lock;
#endif /*ENABLE_MEM_LEAK_CHECK*/
bool_t tk_mem_is_valid_addr(void* addr) {
return ((uintptr_t)addr > 0x10000);
}
static mem_allocator_t* mem_allocator_get(void) {
static mem_allocator_std_t std;
if (s_allocator != NULL) {
return s_allocator;
}
s_allocator = mem_allocator_std_init(&std);
#ifdef ENABLE_MEM_LEAK_CHECK
s_allocator = mem_allocator_debug_init(&s_debug, s_allocator);
s_allocator = mem_allocator_lock_init(&s_lock, s_allocator);
#endif /*ENABLE_MEM_LEAK_CHECK*/
s_allocator = mem_allocator_oom_init(&s_oom, s_allocator);
return s_allocator;
}
ret_t tk_mem_init_stage2(void) {
return RET_OK;
}
#elif defined(WITH_OS_MEM)
#else /*non std memory manager*/
#include "tkc/mem_allocator_lock.h"
#include "tkc/mem_allocator_composite.h"
static mem_allocator_lock_t s_lock;
static mem_allocator_pool_t pool;
static mem_allocator_composite_t composite;
bool_t tk_mem_is_valid_addr(void* addr) {
return mem_allocator_composite_is_valid_addr(MEM_ALLOCATOR(&composite), addr);
}
ret_t tk_mem_init_ex(void* buffer, uint32_t size, ...) {
va_list va;
va_start(va, size);
s_allocator = mem_allocator_composite_init_va(&composite, buffer, size, va);
va_end(va);
return_value_if_fail(s_allocator != NULL, RET_BAD_PARAMS);
if (size > 32 * 1024) {
if (size < 100 * 1024) {
s_allocator = mem_allocator_pool_init(&pool, s_allocator, 100, 100, 80, 80, 32);
} else if (size < 1000 * 1024) {
s_allocator = mem_allocator_pool_init(&pool, s_allocator, 500, 500, 500, 200, 200);
} else {
s_allocator = mem_allocator_pool_init(&pool, s_allocator, 1000, 1000, 1000, 500, 500);
}
}
#ifdef ENABLE_MEM_LEAK_CHECK
s_allocator = mem_allocator_debug_init(&s_debug, s_allocator);
#endif /*ENABLE_MEM_LEAK_CHECK*/
return s_allocator != NULL ? RET_OK : RET_FAIL;
}
ret_t tk_mem_init(void* buffer, uint32_t size) {
return tk_mem_init_ex(buffer, size, NULL, 0);
}
ret_t tk_mem_init_stage2(void) {
return_value_if_fail(s_allocator != NULL, RET_FAIL);
s_allocator = mem_allocator_lock_init(&s_lock, s_allocator);
s_allocator = mem_allocator_oom_init(&s_oom, s_allocator);
return RET_OK;
}
static mem_allocator_t* mem_allocator_get(void) {
return s_allocator;
}
#if (!defined(WITH_SDL) && !defined(LINUX))
#define EXPORT_STD_MALLOC 1
#endif
#if defined(EXPORT_STD_MALLOC)
/*export std malloc*/
void* calloc(size_t count, size_t size) {
return tk_calloc(count, size, __FUNCTION__, __LINE__);
}
void free(void* ptr) {
tk_free(ptr);
}
void* malloc(size_t size) {
return tk_alloc(size, __FUNCTION__, __LINE__);
}
void* realloc(void* ptr, size_t size) {
return tk_realloc(ptr, size, __FUNCTION__, __LINE__);
}
#endif /*WITH_SDL*/
#endif /*HAS_STD_MALLOC*/
#if !defined(WITH_OS_MEM)
void* tk_calloc(uint32_t nmemb, uint32_t size, const char* func, uint32_t line) {
void* addr = NULL;
uint32_t total_size = size * nmemb;
mem_allocator_t* allocator = mem_allocator_get();
return_value_if_fail(allocator != NULL, NULL);
addr = mem_allocator_alloc(allocator, total_size, func, line);
return_value_if_fail(addr != NULL, NULL);
memset(addr, 0x00, total_size);
return addr;
}
void* tk_realloc(void* ptr, uint32_t size, const char* func, uint32_t line) {
mem_allocator_t* allocator = mem_allocator_get();
return_value_if_fail(allocator != NULL, NULL);
return mem_allocator_realloc(allocator, ptr, size, func, line);
}
void* tk_alloc(uint32_t size, const char* func, uint32_t line) {
mem_allocator_t* allocator = mem_allocator_get();
return_value_if_fail(allocator != NULL, NULL);
return mem_allocator_alloc(allocator, size, func, line);
}
void tk_free(void* ptr) {
mem_allocator_t* allocator = mem_allocator_get();
return_if_fail(allocator != NULL);
mem_allocator_free(allocator, ptr);
}
void tk_mem_dump(void) {
mem_allocator_t* allocator = mem_allocator_get();
return_if_fail(allocator != NULL);
mem_allocator_dump(allocator);
}
#endif /*WITH_OS_MEM*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/str_str.h
|
/**
* File: str_to_str.h
* Author: AWTK Develop Team
* Brief: map one str to another str
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-31 Li XianJing <[email protected]> created
*
*/
#ifndef TK_STR_STR_H
#define TK_STR_STR_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class str_str_t
* @annotation ["fake"]
* 字符串-字符串类型。
*
* 负责把一个字符串映射成另外一个字符串。
*
* 示例：
*
* ```c
* static const str_str_t color_values[] = {{"1", "red"}, {"2", "black"}, {"3", "blue"}, {"4", "white"}};
* const char* value = str_str_value(color_values, "3");
* const char* name = str_str_name(color_values, "blue", "0");
* printf("value = %s \n", value);
* printf("name = %s \n", name);
* ```
*/
typedef struct _str_str_t {
const char* name;
const char* value;
} str_str_t;
/**
* @method str_str_value
* 根据name获取对应的value。
*
* @param {const str_str_t*} items str_str_t数组。
* @param {const char*} name name。
*
* @return {const char*} 返回value。
*/
const char* str_str_value(const str_str_t* items, const char* name);
/**
* @method str_str_name
* 根据value获取对应的name。
*
* @param {const str_str_t*} items str_str_t数组。
* @param {const char*} value value
*
* @return {const char*} 返回name。
*/
const char* str_str_name(const str_str_t* items, const char* value);
END_C_DECLS
#endif /*TK_STR_STR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/dl.h
|
/**
* File: dl.h
* Author: AWTK Develop Team
* Brief: dynamic libaray api
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-13 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DL_H
#define TK_DL_H
#include "tkc/types_def.h"
/**
* @class tk_dl_t
* 动态链接库对象。
*/
struct _tk_dl_t;
typedef struct _tk_dl_t tk_dl_t;
BEGIN_C_DECLS
/**
* @method tk_dl_open
* 打开动态链接库。
*
* @param {const char*} filename 文件名。
*
* @return {tk_dl_t*} 动态链接库对象。
*/
tk_dl_t* tk_dl_open(const char* filename);
/**
* @method tk_dl_sym
* 获取指定名称函数的地址。
* @param {tk_dl_t*} dl dl对象。
* @param {const char*} name 函数名。
*
* @return {void*} 返回函数的地址。
*/
void* tk_dl_sym(tk_dl_t* dl, const char* name);
/**
* @method tk_dl_close
* 关闭dl对象。
* @param {tk_dl_t*} dl dl对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_dl_close(tk_dl_t* dl);
/**
* @method tk_dl_error
* 获取最后的错误信息。
*
* @return {const char*} 返回error message.
*/
const char* tk_dl_error(void);
#ifndef TK_DLL_EXT_NAME
#ifdef WIN32
#define TK_DLL_EXT_NAME ".dll"
#define TK_DLL_PRE_NAME ""
#elif defined MACOS
#define TK_DLL_PRE_NAME "lib"
#define TK_DLL_EXT_NAME ".dylib"
#else
#define TK_DLL_PRE_NAME "lib"
#define TK_DLL_EXT_NAME ".so"
#endif
#endif /*TK_DLL_EXT_NAME*/
END_C_DECLS
#endif /*TK_DL_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_thread.c
|
/**
* File: action_thread.c
* Author: AWTK Develop Team
* Brief: action_thread
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-08 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/action_thread.h"
#include "tkc/waitable_action_queue.h"
#include "tkc/waitable_action_queue.h"
static void* action_thread_entry(void* args) {
done_event_t done;
action_thread_t* thread = (action_thread_t*)args;
thread->quit = FALSE;
thread->quited = FALSE;
log_debug("action thread start\n");
while (!(thread->quit)) {
qaction_t* action = NULL;
while (!(thread->quit) && waitable_action_queue_recv(thread->queue, &action, 1000) == RET_OK) {
ret_t ret = qaction_exec(action);
if (ret == RET_QUIT) {
thread->quit = TRUE;
}
if (qaction_notify(action, done_event_init(&done, ret)) == RET_NOT_IMPL) {
qaction_destroy(action);
}
thread->executed_actions_nr++;
}
if (thread->on_idle != NULL) {
if (thread->on_idle(thread->on_idle_ctx, thread) == RET_QUIT) {
thread->quit = TRUE;
break;
}
}
}
thread->quited = TRUE;
if (thread->on_quit != NULL) {
thread->on_quit(thread->on_quit_ctx, thread);
}
log_debug("action thread done\n");
return NULL;
}
static action_thread_t* action_thread_create_internal(void) {
action_thread_t* thread = NULL;
thread = TKMEM_ZALLOC(action_thread_t);
return_value_if_fail(thread != NULL, NULL);
thread->thread = tk_thread_create(action_thread_entry, thread);
goto_error_if_fail(thread->thread != NULL);
return thread;
error:
TKMEM_FREE(thread);
return NULL;
}
action_thread_t* action_thread_create(void) {
return action_thread_create_ex(NULL, 0, TK_THREAD_PRIORITY_NORMAL);
}
action_thread_t* action_thread_create_ex(const char* name, uint32_t stack_size,
tk_thread_priority_t priority) {
action_thread_t* thread = NULL;
waitable_action_queue_t* queue = waitable_action_queue_create(10);
return_value_if_fail(queue != NULL, NULL);
thread = action_thread_create_internal();
if (thread != NULL) {
thread->queue = queue;
if (name != NULL) {
tk_thread_set_name(thread->thread, name);
}
if (priority != TK_THREAD_PRIORITY_NORMAL) {
tk_thread_set_priority(thread->thread, priority);
}
if (stack_size != 0) {
tk_thread_set_stack_size(thread->thread, stack_size);
}
tk_thread_start(thread->thread);
} else {
waitable_action_queue_destroy(queue);
}
return thread;
}
action_thread_t* action_thread_create_with_queue(waitable_action_queue_t* queue) {
return action_thread_create_with_queue_ex(queue, NULL, 0, TK_THREAD_PRIORITY_NORMAL);
}
action_thread_t* action_thread_create_with_queue_ex(waitable_action_queue_t* queue,
const char* name, uint32_t stack_size,
tk_thread_priority_t priority) {
action_thread_t* thread = NULL;
return_value_if_fail(queue != NULL, NULL);
thread = action_thread_create_internal();
return_value_if_fail(thread != NULL, NULL);
if (thread != NULL) {
thread->queue = queue;
thread->is_shared_queue = TRUE;
if (name != NULL) {
tk_thread_set_name(thread->thread, name);
}
if (priority != TK_THREAD_PRIORITY_NORMAL) {
tk_thread_set_priority(thread->thread, priority);
}
if (stack_size != 0) {
tk_thread_set_stack_size(thread->thread, stack_size);
}
tk_thread_start(thread->thread);
}
return thread;
}
ret_t action_thread_exec(action_thread_t* thread, qaction_t* action) {
return_value_if_fail(thread != NULL && thread->queue != NULL, RET_BAD_PARAMS);
return_value_if_fail(action != NULL && action->exec != NULL, RET_BAD_PARAMS);
return waitable_action_queue_send(thread->queue, action, 3000);
}
static ret_t qaction_quit_exec(qaction_t* action) {
return_value_if_fail(action != NULL, RET_BAD_PARAMS);
return RET_QUIT;
}
static ret_t action_thread_quit(action_thread_t* thread) {
qaction_t* a = qaction_create(qaction_quit_exec, NULL, 0);
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
if (thread->quited || !thread->queue) {
return RET_OK;
}
thread->quit = TRUE;
return waitable_action_queue_send(thread->queue, a, 3000);
}
ret_t action_thread_destroy(action_thread_t* thread) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
action_thread_quit(thread);
tk_thread_join(thread->thread);
tk_thread_destroy(thread->thread);
if (!thread->is_shared_queue) {
waitable_action_queue_destroy(thread->queue);
}
TKMEM_FREE(thread);
return RET_OK;
}
ret_t action_thread_set_on_idle(action_thread_t* thread, action_thread_on_idle_t on_idle,
void* ctx) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
thread->on_idle = on_idle;
thread->on_idle_ctx = ctx;
return RET_OK;
}
ret_t action_thread_set_on_quit(action_thread_t* thread, action_thread_on_quit_t on_quit,
void* ctx) {
return_value_if_fail(thread != NULL, RET_BAD_PARAMS);
thread->on_quit = on_quit;
thread->on_quit_ctx = ctx;
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/slist.h
|
/**
* File: slist.h
* Author: AWTK Develop Team
* Brief: single link list
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-11 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SLIST_H
#define TK_SLIST_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
typedef struct _slist_node_t {
struct _slist_node_t* next;
void* data;
} slist_node_t;
/**
* @class slist_t
* 单向链表
*
* 用slist\_init初始化时，用slist\_deinit释放。如：
*
* ```c
* slist_t slist;
* slist_init(&slist, destroy, compare);
* ...
* slist_deinit(&slist);
* ```
*
* 用slist\_create创建时，用slist\_destroy销毁。如：
*
* ```c
* slist_t* slist = slist_create(destroy, compare);
* ...
* slist_destroy(slist);
* ```
*
*/
typedef struct _slist_t {
/**
* @property {slist_node_t*} first
* @annotation ["readable"]
* 首节点。
*/
slist_node_t* first;
/**
* @property {tk_destroy_t} destroy
* @annotation ["readable"]
* 元素销毁函数。
*/
tk_destroy_t destroy;
/**
* @property {tk_compare_t} compare
* @annotation ["readable"]
* 元素比较函数。
*/
tk_compare_t compare;
} slist_t;
/**
* @method slist_create
* @annotation ["constructor"]
* 创建slist对象
* @param {tk_destroy_t} destroy 元素销毁函数。
* @param {tk_compare_t} compare 元素比较函数。
*
* @return {slist_t*} 单向链表对象。
*/
slist_t* slist_create(tk_destroy_t destroy, tk_compare_t compare);
/**
* @method slist_init
* 初始化slist对象
* @param {slist_t*} slist 单向链表对象。
* @param {tk_destroy_t} destroy 元素销毁函数。
* @param {tk_compare_t} compare 元素比较函数。
*
* @return {slist_t*} 单向链表对象。
*/
slist_t* slist_init(slist_t* slist, tk_destroy_t destroy, tk_compare_t compare);
/**
* @method slist_find
* 查找第一个满足条件的元素。
* @param {slist_t*} slist 单向链表对象。
* @param {void*} ctx 比较函数的上下文。
*
* @return {void*} 如果找到，返回满足条件的对象，否则返回NULL。
*/
void* slist_find(slist_t* slist, void* ctx);
/**
* @method slist_find_ex
* 查找第一个满足条件的元素。
* @param {slist_t*} slist 单向链表对象。
* @param {tk_compare_t} compare 元素比较函数。
* @param {void*} ctx 比较函数的上下文。
*
* @return {void*} 返回节点。
*/
void* slist_find_ex(slist_t* slist, tk_compare_t compare, void* ctx);
/**
* @method slist_remove
* 删除第一个满足条件的元素。
* @param {slist_t*} slist 单向链表对象。
* @param {void*} ctx 比较函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_remove(slist_t* slist, void* ctx);
/**
* @method slist_remove_ex
* 删除满足条件的元素。
* 备注：
* 如果队列中符合条件的元素不足 remove_size，移除最后一个符合条件的元素后返回 RET_OK。
* 如果队列中符合条件的元素大于 remove_size，在队列中移除 remove_size 个元素后返回 RET_OK。
* remove_size 为负数则会移除所有符合条件的元素。
* @param {slist_t*} slist 单向链表对象。
* @param {tk_compare_t} compare 元素比较函数。
* @param {void*} ctx 比较函数的上下文。
* @param {int32_t} remove_size 删除个数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_remove_ex(slist_t* slist, tk_compare_t compare, void* ctx, int32_t remove_size);
#define slist_remove_with_compare(slist, ctx, compare, remove_size) \
slist_remove_ex(slist, compare, ctx, remove_size)
/**
* @method slist_remove_all
* 删除全部元素。
* @param {slist_t*} slist 单向链表对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_remove_all(slist_t* slist);
/**
* @method slist_append
* 在尾巴追加一个元素。
* @param {slist_t*} slist 单向链表对象。
* @param {void*} data 待追加的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_append(slist_t* slist, void* data);
/**
* @method slist_insert
* 插入一个元素。
* @param {slist_t*} slist 单向链表对象。
* @param {uint32_t} index 位置序数。
* @param {void*} data 待追加的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_insert(slist_t* slist, uint32_t index, void* data);
/**
* @method slist_prepend
* 在头部追加一个元素。
* @param {slist_t*} slist 单向链表对象。
* @param {void*} data 待追加的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_prepend(slist_t* slist, void* data);
/**
* @method slist_foreach
* 遍历元素。
* @param {slist_t*} slist 单向链表对象。
* @param {tk_visit_t} visit 遍历函数。
* @param {void*} ctx 遍历函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_foreach(slist_t* slist, tk_visit_t visit, void* ctx);
/**
* @method slist_tail_pop
* 弹出最后一个元素。
* @param {slist_t*} slist 单向链表对象。
*
* @return {void*} 成功返回最后一个元素，失败返回NULL。
*/
void* slist_tail_pop(slist_t* slist);
/**
* @method slist_head_pop
* 弹出第一个元素。
* @param {slist_t*} slist 单向链表对象。
*
* @return {void*} 成功返回最后一个元素，失败返回NULL。
*/
void* slist_head_pop(slist_t* slist);
/**
* @method slist_tail
* 返回最后一个元素。
* @param {slist_t*} slist 单向链表对象。
*
* @return {void*} 成功返回最后一个元素，失败返回NULL。
*/
void* slist_tail(slist_t* slist);
/**
* @method slist_head
* 返回第一个元素。
* @param {slist_t*} slist 单向链表对象。
*
* @return {void*} 成功返回最后一个元素，失败返回NULL。
*/
void* slist_head(slist_t* slist);
/**
* @method slist_is_empty
* 列表是否为空。
* @param {slist_t*} slist 单向链表对象。
*
* @return {bool_t} 返回 TRUE 表示空列表，返回 FALSE 表示列表有数据。
*/
bool_t slist_is_empty(slist_t* slist);
/**
* @method slist_size
* 返回元素个数。
* @param {slist_t*} slist 单向链表对象。
*
* @return {int32_t} 返回元素个数。
*/
int32_t slist_size(slist_t* slist);
/**
* @method slist_count
* 返回满足条件元素的个数。
* @param {slist_t*} slist 单向链表对象。
* @param {void*} ctx 比较函数的上下文。
*
* @return {int32_t} 返回元素个数。
*/
int32_t slist_count(slist_t* slist, void* ctx);
/**
* @method slist_deinit
* 清除单向链表中的元素。
* @param {slist_t*} slist 单向链表对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t slist_deinit(slist_t* slist);
/**
* @method slist_destroy
* 清除单向链表中的元素，并释放单向链表对象。
* @param {slist_t*} slist 单向链表对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t slist_destroy(slist_t* slist);
END_C_DECLS
#endif /*TK_SLIST_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/typed_array.h
|
/**
* File: typed_array.h
* Author: AWTK Develop Team
* Brief: dynamic typed_array.
*
* Copyright (c) 2021 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TYPED_ARRAY_H
#define TK_TYPED_ARRAY_H
#include "tkc/value.h"
#include "tkc/buffer.h"
BEGIN_C_DECLS
/**
* @class typed_array_t
* 带类型的动态数组，根据元素个数动态调整数组的容量。
*
* 示例：
*
* ```c
* value_t v;
* typed_array_t* a = typed_array_create(VALUE_TYPE_INT, 10);
* typed_array_push(a, value_set_int(&v, 123));
* typed_array_push(a, value_set_int(&v, 234));
* ...
* typed_array_destroy(a);
* ```
*
*/
typedef struct _typed_array_t {
/**
* @property {uint32_t} size
* @annotation ["readable"]
* 数组中元素的个数。
*/
uint32_t size;
/**
* @property {uint32_t} capacity
* @annotation ["readable"]
* 数组的容量大小。
*/
uint32_t capacity;
/**
* @property {uint8_t*} data
* @annotation ["readable"]
* 数组中的元素。
*/
uint8_t* data;
/**
* @property {value_type_t} type
* @annotation ["readable"]
* 元素的类型。
*/
value_type_t type;
/**
* @property {uint32_t} element_size
* @annotation ["readable"]
* 单个元素的大小。
*/
uint32_t element_size;
} typed_array_t;
/**
* @method typed_array_create
* @annotation ["constructor"]
* 创建typed_array对象。
*
* @param {value_type_t} type 元素的类型。
* @param {uint32_t} capacity 数组的初始容量(元素个数)。
*
* @return {typed_array_t*} 数组对象。
*/
typed_array_t* typed_array_create(value_type_t type, uint32_t capacity);
/**
* @method typed_array_extend
* 扩展typed_array到指定容量。
*
* @param {typed_array_t*} typed_array 元素的类型。
* @param {uint32_t} capacity 数组的容量(元素个数)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_extend(typed_array_t* typed_array, uint32_t capacity);
/**
* @method typed_array_get
* 获取指定序数的元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {uint32_t} index 序数。
* @param {value_t*} v 返回的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_get(typed_array_t* typed_array, uint32_t index, value_t* v);
/**
* @method typed_array_set
* 设置指定序数的元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {uint32_t} index 序数。
* @param {const value_t*} v 元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_set(typed_array_t* typed_array, uint32_t index, const value_t* v);
/**
* @method typed_array_insert
* 在指定序数插入元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {uint32_t} index 序数。
* @param {const value_t*} v 元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_insert(typed_array_t* typed_array, uint32_t index, const value_t* v);
/**
* @method typed_array_remove
* 删除指定位置的元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {uint32_t} index 位置序数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_remove(typed_array_t* typed_array, uint32_t index);
/**
* @method typed_array_pop
* 弹出最后一个元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {value_t*} v 弹出的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_pop(typed_array_t* typed_array, value_t* v);
/**
* @method typed_array_tail
* 返回最后一个元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {value_t*} v 返回的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_tail(typed_array_t* typed_array, value_t* v);
/**
* @method typed_array_push
* 在尾巴追加一个元素。
* @param {typed_array_t*} typed_array 数组对象。
* @param {const value_t*} v 待追加的元素。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_push(typed_array_t* typed_array, const value_t* v);
/**
* @method typed_array_clear
* 清除全部元素。
* @param {typed_array_t*} typed_array 数组对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_clear(typed_array_t* typed_array);
/**
* @method typed_array_destroy
* 销毁typed_array对象。
* @param {typed_array_t*} typed_array 数组对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t typed_array_destroy(typed_array_t* typed_array);
END_C_DECLS
#endif /*TK_TYPED_ARRAY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer_factory.c
|
/**
* File: data_writer_factory.c
* Author: AWTK Develop Team
* Brief: data writer factory
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-01 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/data_writer_factory.h"
static data_writer_factory_t* data_writer_factory_init(data_writer_factory_t* factory);
static ret_t data_writer_factory_deinit(data_writer_factory_t* factory);
static data_writer_factory_t* s_data_writer_factory = NULL;
typedef struct _creator_item_t {
char protocol[TK_NAME_LEN + 1];
data_writer_create_t create;
} creator_item_t;
static int32_t creator_item_cmp(const creator_item_t* iter, const char* protocol) {
return strcmp(iter->protocol, protocol);
}
data_writer_factory_t* data_writer_factory(void) {
return s_data_writer_factory;
}
data_writer_factory_t* data_writer_factory_create(void) {
data_writer_factory_t* factory = TKMEM_ZALLOC(data_writer_factory_t);
return_value_if_fail(factory != NULL, NULL);
return data_writer_factory_init(factory);
}
static data_writer_factory_t* data_writer_factory_init(data_writer_factory_t* factory) {
return_value_if_fail(factory != NULL, NULL);
darray_init(&(factory->creators), 0, default_destroy, (tk_compare_t)creator_item_cmp);
return factory;
}
ret_t data_writer_factory_register(data_writer_factory_t* factory, const char* protocol,
data_writer_create_t create) {
creator_item_t* item = NULL;
return_value_if_fail(factory != NULL && protocol != NULL && create != NULL, RET_BAD_PARAMS);
item = darray_find(&(factory->creators), (void*)protocol);
if (item != NULL) {
if (item->create != create) {
item->create = create;
}
} else {
item = TKMEM_ZALLOC(creator_item_t);
return_value_if_fail(item != NULL, RET_OOM);
item->create = create;
tk_strncpy(item->protocol, protocol, TK_NAME_LEN);
darray_push(&(factory->creators), item);
}
return RET_OK;
}
data_writer_t* data_writer_factory_create_writer(data_writer_factory_t* factory, const char* url) {
char protocol[TK_NAME_LEN + 1];
const char* p = NULL;
const creator_item_t* iter = NULL;
return_value_if_fail(factory != NULL && url != NULL, NULL);
p = strchr(url, ':');
memset(protocol, 0x00, sizeof(protocol));
if (p != NULL) {
return_value_if_fail((p - url) < TK_NAME_LEN, NULL);
tk_strncpy(protocol, url, p - url);
if (tk_strlen(protocol) <= 1) {
/*是Windows下的盘符(如 D:/a/b/c.txt)*/
tk_strncpy(protocol, "file", 4);
}
} else {
tk_strncpy(protocol, "file", 4);
}
iter = darray_find(&(factory->creators), (void*)protocol);
if (iter != NULL) {
p = strstr(url, "://");
if (p == NULL) {
p = url;
} else {
p += 3;
}
return iter->create(p);
}
return NULL;
}
ret_t data_writer_factory_set(data_writer_factory_t* factory) {
s_data_writer_factory = factory;
return RET_OK;
}
static ret_t data_writer_factory_deinit(data_writer_factory_t* factory) {
return_value_if_fail(factory != NULL, RET_BAD_PARAMS);
darray_deinit(&(factory->creators));
return RET_OK;
}
ret_t data_writer_factory_destroy(data_writer_factory_t* factory) {
return_value_if_fail(factory != NULL, RET_BAD_PARAMS);
data_writer_factory_deinit(factory);
TKMEM_FREE(factory);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/rlog.c
|
/**
* File: rlog.c
* Author: AWTK Develop Team
* Brief: rotate log api
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-11-18 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/rlog.h"
#include "tkc/utils.h"
#include "tkc/mutex_nest.h"
#ifdef HAS_STDIO
#define my_return_value_if_fail(p, value) \
if (!(p)) { \
printf("%s:%d condition(" #p ") failed!\n", __FUNCTION__, __LINE__); \
fflush(stdout); \
return (value); \
}
#else
#define my_return_value_if_fail(p, value) \
if (!(p)) { \
return (value); \
}
#endif
rlog_t* rlog_create(const char* filename_pattern, uint32_t max_size, uint32_t buff_size) {
rlog_t* log = NULL;
fs_stat_info_t fst;
fs_file_t* fp = NULL;
uint32_t index = 0;
char filename[MAX_PATH + 1];
my_return_value_if_fail(filename_pattern != NULL && max_size > 1000 && buff_size > 32, NULL);
memset(filename, 0x00, sizeof(filename));
tk_snprintf(filename, MAX_PATH, filename_pattern, (int)index);
if (fs_stat(os_fs(), filename, &fst) == RET_OK) {
if (fst.size < (max_size - buff_size)) {
fp = fs_open_file(os_fs(), filename, "ab+");
} else {
index = 1;
tk_snprintf(filename, MAX_PATH, filename_pattern, (int)(index));
fp = fs_open_file(os_fs(), filename, "ab+");
}
} else {
fp = fs_open_file(os_fs(), filename, "wb+");
}
my_return_value_if_fail(fp != NULL, NULL);
log = TKMEM_ZALLOC(rlog_t);
if (log != NULL) {
log->index = index;
log->max_size = max_size;
log->buff_size = buff_size;
log->mutex = tk_mutex_nest_create();
log->filename_pattern = tk_strdup(filename_pattern);
if (log->filename_pattern != NULL) {
log->fp = fp;
} else {
fs_file_close(fp);
TKMEM_FREE(log);
}
} else {
fs_file_close(fp);
}
return log;
}
ret_t rlog_write(rlog_t* log, const char* str) {
uint32_t len = 0;
fs_stat_info_t fst;
my_return_value_if_fail(log != NULL && log->fp != NULL && str != NULL, RET_BAD_PARAMS);
my_return_value_if_fail(fs_file_stat(log->fp, &fst) == RET_OK, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(log->mutex) == RET_OK) {
len = strlen(str);
if ((fst.size + len) > log->max_size) {
char filename0[MAX_PATH + 1];
char filename1[MAX_PATH + 1];
fs_file_close(log->fp);
memset(filename1, 0x00, sizeof(filename1));
tk_snprintf(filename1, MAX_PATH, log->filename_pattern, (int)1);
if (log->index == 1) {
memset(filename0, 0x00, sizeof(filename0));
tk_snprintf(filename0, MAX_PATH, log->filename_pattern, (int)0);
fs_remove_file(os_fs(), filename0);
fs_file_rename(os_fs(), filename1, filename0);
}
log->index = 1;
log->fp = fs_open_file(os_fs(), filename1, "wb+");
}
if (log->fp != NULL) {
fs_file_write(log->fp, str, len);
fs_file_sync(log->fp);
}
tk_mutex_nest_unlock(log->mutex);
}
return RET_OK;
}
ret_t rlog_print(rlog_t* log, const char* format, ...) {
va_list va;
ret_t ret = RET_OK;
my_return_value_if_fail(log != NULL && log->fp != NULL && format != NULL, RET_BAD_PARAMS);
my_return_value_if_fail(log->buff_size > 0, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(log->mutex) == RET_OK) {
if (log->buff == NULL) {
log->buff = TKMEM_ALLOC(log->buff_size + 1);
if (log->buff == NULL) {
tk_mutex_nest_unlock(log->mutex);
return RET_OOM;
}
memset(log->buff, 0x00, log->buff_size + 1);
}
va_start(va, format);
tk_vsnprintf(log->buff, log->buff_size, format, va);
va_end(va);
ret = rlog_write(log, log->buff);
tk_mutex_nest_unlock(log->mutex);
}
return ret;
}
ret_t rlog_destroy(rlog_t* log) {
my_return_value_if_fail(log != NULL, RET_BAD_PARAMS);
TKMEM_FREE(log->buff);
fs_file_close(log->fp);
TKMEM_FREE(log->filename_pattern);
tk_mutex_nest_destroy(log->mutex);
memset(log, 0x00, sizeof(rlog_t));
TKMEM_FREE(log);
return RET_OK;
}
ret_t rlog_clear(rlog_t* log) {
char filename[MAX_PATH + 1];
ret_t ret;
my_return_value_if_fail(log, RET_BAD_PARAMS);
ret = tk_mutex_nest_lock(log->mutex);
my_return_value_if_fail(ret == RET_OK, RET_FAIL);
fs_file_close(log->fp);
tk_snprintf(filename, MAX_PATH, log->filename_pattern, (int)0);
fs_remove_file(os_fs(), filename);
log->fp = fs_open_file(os_fs(), filename, "wb+");
if (log->index == 1) {
tk_snprintf(filename, MAX_PATH, log->filename_pattern, (int)1);
fs_remove_file(os_fs(), filename);
log->index = 0;
}
tk_mutex_nest_unlock(log->mutex);
my_return_value_if_fail(log->fp != NULL, RET_FAIL);
return RET_OK;
}
ret_t rlog_size(rlog_t* log, uint32_t* size) {
char filename[MAX_PATH + 1];
ret_t ret;
int32_t sz = 0;
my_return_value_if_fail(log && size, RET_BAD_PARAMS);
ret = tk_mutex_nest_lock(log->mutex);
my_return_value_if_fail(ret == RET_OK, RET_FAIL);
tk_snprintf(filename, MAX_PATH, log->filename_pattern, (int)0);
sz = file_get_size(filename);
goto_error_if_fail(sz >= 0);
*size = sz;
if (log->index == 1) {
tk_snprintf(filename, MAX_PATH, log->filename_pattern, (int)1);
sz = file_get_size(filename);
goto_error_if_fail(sz >= 0);
*size += sz;
}
tk_mutex_nest_unlock(log->mutex);
return RET_OK;
error:
tk_mutex_nest_unlock(log->mutex);
return RET_FAIL;
}
ret_t rlog_read(rlog_t* log, uint32_t offs, char* buff, uint32_t buffsz, uint32_t* readsz) {
char filename[MAX_PATH + 1];
int32_t ret;
int32_t sz = 0;
my_return_value_if_fail(log && buff && buffsz && readsz, RET_BAD_PARAMS);
ret = tk_mutex_nest_lock(log->mutex);
my_return_value_if_fail(ret == RET_OK, RET_FAIL);
tk_snprintf(filename, MAX_PATH, log->filename_pattern, (int)0);
sz = file_get_size(filename);
goto_error_if_fail(sz >= 0);
if (offs < sz) {
ret = file_read_part(filename, buff, buffsz, offs);
goto_error_if_fail(ret >= 0);
offs = 0;
buff += ret;
buffsz -= ret;
*readsz = ret;
} else {
offs -= sz;
}
if (buffsz == 0 || log->index == 0) {
tk_mutex_nest_unlock(log->mutex);
return RET_OK;
}
tk_snprintf(filename, MAX_PATH, log->filename_pattern, (int)1);
ret = file_get_size(filename);
goto_error_if_fail(ret >= 0);
goto_error_if_fail(offs < sz);
ret = file_read_part(filename, buff, buffsz, offs);
goto_error_if_fail(ret >= 0);
*readsz += ret;
tk_mutex_nest_unlock(log->mutex);
return RET_OK;
error:
tk_mutex_nest_unlock(log->mutex);
return RET_FAIL;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer_wbuffer.h
|
/**
* File: data_writer_wbuffer.h
* Author: AWTK Develop Team
* Brief: data_writer wbuffer
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License wbuffer for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-23 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_WRITER_WBUFFER_H
#define TK_DATA_WRITER_WBUFFER_H
#include "tkc/utils.h"
#include "tkc/buffer.h"
#include "tkc/data_writer.h"
BEGIN_C_DECLS
/**
* @class data_writer_wbuffer_t
* @parent data_writer_t
* @annotation ["fake"]
* 基于内存实现的 data_writer。通过 data_writer_factory 创建 writer 时，URL的格式如下(请用函数data_writer_wbuffer_build_url生成)：
*
* ```
* wbuffer://addr
* ```
*/
/**
* @method data_writer_wbuffer_create
* 创建基于wbuffer的data writer。
*
* > 不要直接调用，而是注册到 data\_writer\_factory后，通过data\_writer\_factory调用
* @annotation ["constructor"]
* @param {const char*} wbuffer_name wbuffer地址的字符串格式表示 。
*
* @return {data_writer_t*} 返回data writer对象。
*/
data_writer_t* data_writer_wbuffer_create(const char* wbuffer_name);
/**
* @method data_writer_wbuffer_build_url
* 构造wbuffer的URL。
* @annotation ["static"]
*
* @param {wbuffer_t*} wbuffer wbuffer对象。
* @param {char*} url 生成的URL。
*
* @return {const char*} 返回URL。
*/
const char* data_writer_wbuffer_build_url(wbuffer_t* wbuffer, char url[MAX_PATH + 1]);
#define DATA_WRITER_WBUFFER(writer) ((data_writer_t*)(writer))
END_C_DECLS
#endif /*TK_DATA_WRITER_WBUFFER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/timer_manager.h
|
/**
* File: timer_manager.h
* Author: AWTK Develop Team
* Brief: timer manager
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TIMER_MANAGER_H
#define TK_TIMER_MANAGER_H
#include "tkc/slist.h"
#include "tkc/timer_info.h"
BEGIN_C_DECLS
/**
* @class timer_manager_t
* @annotation ["scriptable"]
*
* 定时器管理器。
*/
struct _timer_manager_t {
uint32_t next_timer_id;
uint64_t last_dispatch_time;
timer_get_time_t get_time;
slist_t timers;
};
/**
* @method timer_manager
* 获取缺省的定时器管理器。
* @annotation ["constructor"]
* @return {timer_manager_t*} 返回定时器管理器对象。
*/
timer_manager_t* timer_manager(void);
/**
* @method timer_manager_set
* 设置缺省的定时器管理器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_set(timer_manager_t* timer_manager);
/**
* @method timer_manager_create
* 创建定时器管理器。
* @annotation ["constructor"]
* @param {timer_get_time_t} get_time 获取当前时间的函数。
*
* @return {timer_manager_t*} 返回定时器管理器对象。
*/
timer_manager_t* timer_manager_create(timer_get_time_t get_time);
/**
* @method timer_manager_init
* 初始化定时器管理器。
* @annotation ["constructor"]
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {timer_get_time_t} get_time 获取当前时间的函数。
*
* @return {timer_manager_t*} 返回定时器管理器对象。
*/
timer_manager_t* timer_manager_init(timer_manager_t* timer_manager, timer_get_time_t get_time);
/**
* @method timer_manager_deinit
* 析构定时器管理器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_deinit(timer_manager_t* timer_manager);
/**
* @method timer_manager_destroy
* 析构并释放定时器管理器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_destroy(timer_manager_t* timer_manager);
/**
* @method timer_manager_add
* 添加定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {timer_func_t} on_timer timer回调函数。
* @param {void*} ctx timer回调函数的上下文。
* @param {uint32_t} duration 时间(毫秒)。
*
* @return {uint32_t} 返回timer的ID，TK_INVALID_ID表示失败。
*/
uint32_t timer_manager_add(timer_manager_t* timer_manager, timer_func_t on_timer, void* ctx,
uint32_t duration);
/**
* @method timer_manager_add_with_id
* 添加定时器。（可以指定 timer_id ，如果发现 timer_id 冲突则添加失败）。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {uint32_t} id timer_id。
* @param {timer_func_t} on_timer timer回调函数。
* @param {void*} ctx timer回调函数的上下文。
* @param {uint32_t} duration 时间(毫秒)。
*
* @return {uint32_t} 返回timer的ID，TK_INVALID_ID表示失败。
*/
uint32_t timer_manager_add_with_id(timer_manager_t* timer_manager, uint32_t id,
timer_func_t on_timer, void* ctx, uint32_t duration);
/**
* @method timer_manager_remove
* 根据id删除定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {uint32_t} timer_id timer_id。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_remove(timer_manager_t* timer_manager, uint32_t timer_id);
/**
* @method timer_manager_all_remove_by_ctx
* 根据上下文删除所有对应的定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {void*} ctx timer回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_all_remove_by_ctx(timer_manager_t* timer_manager, void* ctx);
/**
* @method timer_manager_reset
* 重置定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {uint32_t} timer_id timer_id。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_reset(timer_manager_t* timer_manager, uint32_t timer_id);
/**
* @method timer_manager_find
* 查找指定ID的定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {uint32_t} timer_id timer_id
*
* @return {const timer_info_t*} 返回timer的信息。
*/
const timer_info_t* timer_manager_find(timer_manager_t* timer_manager, uint32_t timer_id);
/**
* @method timer_manager_dispatch
* 检查全部定时器的函数，如果时间到期，调用相应的timer函数。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_dispatch(timer_manager_t* timer_manager);
/**
* @method timer_manager_count
* 返回定时器的个数。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {uint32_t} 返回timer的个数。
*/
uint32_t timer_manager_count(timer_manager_t* timer_manager);
/**
* @method timer_manager_next_time
* 返回最近的定时器到期时间(毫秒)。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {uint64_t} 返回最近的timer到期时间(毫秒)。
*/
uint64_t timer_manager_next_time(timer_manager_t* timer_manager);
/**
* @method timer_manager_append
* 追加定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。。
* @param {timer_info_t*} timer timer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_append(timer_manager_t* timer_manager, timer_info_t* timer);
/**
* @method timer_manager_get_next_timer_id
* 获取下一个可用的 timer_id。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {uint32_t} 返回idle的ID，TK_INVALID_ID表示失败。
*/
uint32_t timer_manager_get_next_timer_id(timer_manager_t* timer_manager);
/*internal use*/
/**
* @method timer_manager_all_remove_by_ctx_and_type
* 移除对应类型和上下文的所有定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {uint16_t} type 类型。
* @param {void*} ctx 上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t timer_manager_all_remove_by_ctx_and_type(timer_manager_t* timer_manager, uint16_t type,
void* ctx);
/**
* @method timer_manager_add_with_type
* 添加对应类型的定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {timer_func_t} on_timer 定时器回调函数。
* @param {void*} ctx 上下文。
* @param {uint32_t} duration 时间(毫秒)。
* @param {uint16_t} timer_info_type timer_info_type。
*
* @return {uint32_t} 返回定时器id。
*/
uint32_t timer_manager_add_with_type(timer_manager_t* timer_manager, timer_func_t on_timer,
void* ctx, uint32_t duration, uint16_t timer_info_type);
/**
* @method timer_manager_add_with_type_and_id
* 添加对应类型和id的定时器。
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
* @param {uint32_t} id id。
* @param {timer_func_t} on_timer 定时器回调函数。
* @param {void*} ctx 上下文。
* @param {uint32_t} duration 时间(毫秒)。
* @param {uint16_t} timer_info_type timer_info_type。
* @param {bool_t} is_check_id 是否校验id。
*
* @return {uint32_t} 返回定时器id。
*/
uint32_t timer_manager_add_with_type_and_id(timer_manager_t* timer_manager, uint32_t id,
timer_func_t on_timer, void* ctx, uint32_t duration,
uint16_t timer_info_type, bool_t is_check_id);
END_C_DECLS
#endif /*TK_TIMER_MANAGER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_factory.h
|
/**
* File: data_reader_factory.h
* Author: AWTK Develop Team
* Brief: data reader factory
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-03-01 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_READER_FACTORY_H
#define TK_DATA_READER_FACTORY_H
#include "tkc/darray.h"
#include "tkc/data_reader.h"
BEGIN_C_DECLS
typedef data_reader_t* (*data_reader_create_t)(const char* args);
/**
* @class data_reader_factory_t
* data reader工厂。
*
*/
typedef struct _data_reader_factory_t {
/*private*/
darray_t creators;
} data_reader_factory_t;
/**
* @method data_reader_factory
* 获取缺省的data reader工厂对象。
* @annotation ["constructor"]
* @return {data_reader_factory_t*} 返回data reader工厂对象。
*/
data_reader_factory_t* data_reader_factory(void);
/**
* @method data_reader_factory_set
* 设置缺省的data reader工厂对象。
* @param {data_reader_factory_t*} factory data reader工厂对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_reader_factory_set(data_reader_factory_t* factory);
/**
* @method data_reader_factory_create
* 创建data reader工厂对象。
* @annotation ["constructor"]
*
* @return {data_reader_factory_t*} 返回data reader工厂对象。
*/
data_reader_factory_t* data_reader_factory_create(void);
/**
* @method data_reader_factory_register
* 注册data reader创建函数。
* @param {data_reader_factory_t*} factory reader工厂对象。
* @param {const char*} protocol 协议(如file)。
* @param {data_reader_create_t} create data reader创建函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_reader_factory_register(data_reader_factory_t* factory, const char* protocol,
data_reader_create_t create);
/**
* @method data_reader_factory_create_reader
* 创建指定类型的data reader对象。
* @annotation ["constructor"]
* @param {data_reader_factory_t*} factory data reader工厂对象。
* @param {const char*} url URL。
*
* @return {data_reader_t*} 返回data reader对象。
*/
data_reader_t* data_reader_factory_create_reader(data_reader_factory_t* factory, const char* url);
/**
* @method data_reader_factory_destroy
* 析构并释放data reader工厂对象。
* @param {data_reader_factory_t*} factory data reader工厂对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_reader_factory_destroy(data_reader_factory_t* factory);
END_C_DECLS
#endif /*TK_DATA_READER_FACTORY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event.h
|
/**
* File: event.h
* Author: AWTK Develop Team
* Brief: event
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EVENT_H
#define TK_EVENT_H
#include "tkc/value.h"
BEGIN_C_DECLS
/**
* @enum event_type_t
* @annotation ["scriptable"]
* @prefix EVT_
* 类型常量定义。
*/
typedef enum _event_base_type_t {
/**
* @const EVT_NONE
* 无效事件名称。
*/
EVT_NONE = 0,
/**
* @const EVT_PROP_WILL_CHANGE
* 对象的属性即将改变的事件名(prop_change_event_t)。
*/
EVT_PROP_WILL_CHANGE,
/**
* @const EVT_PROP_CHANGED
* 对象的属性改变的事件名(prop_change_event_t)。
*/
EVT_PROP_CHANGED,
/**
* @const EVT_CMD_WILL_EXEC
* 对象即将执行命令(cmd_exec_event_t)。
*/
EVT_CMD_WILL_EXEC,
/**
* @const EVT_CMD_EXECED
* 对象完成执行命令(cmd_exec_event_t)。
*/
EVT_CMD_EXECED,
/**
* @const EVT_CMD_CAN_EXEC
* 对象命令是否能执行指定的命令(cmd_exec_event_t)。
*/
EVT_CMD_CAN_EXEC,
/**
* @const EVT_ITEMS_WILL_CHANGE
* 即将增加和删除集合中的项目(event_t)。
*/
EVT_ITEMS_WILL_CHANGE,
/**
* @const EVT_ITEMS_CHANGED
* 完成增加和删除集合中的项目(event_t)。
*/
EVT_ITEMS_CHANGED,
/**
* @const EVT_PROPS_CHANGED
* 对象的属性改变的事件名(props_event_t)。
*/
EVT_PROPS_CHANGED,
/**
* @const EVT_PROGRESS
* 进度状态(progress_event_t)。
*/
EVT_PROGRESS,
/**
* @const EVT_DONE
* 完成(done_event_t)。
*/
EVT_DONE,
/**
* @const EVT_ERROR
* 错误(error_event_t)。
*/
EVT_ERROR,
/**
* @const EVT_DESTROY
* 对象销毁事件名(event_t)。
*/
EVT_DESTROY,
/**
* @const EVT_VALUE_WILL_CHANGE
* 值即将改变的事件名(value_change_event_t)。
*/
EVT_VALUE_WILL_CHANGE,
/**
* @const EVT_VALUE_CHANGED
* 值改变的事件名(value_change_event_t)。
*/
EVT_VALUE_CHANGED,
/**
* @const EVT_VALUE_CHANGING
* 值持续改变(如编辑器正在编辑)的事件名(value_change_event_t)。
*/
EVT_VALUE_CHANGING,
/**
* @const EVT_LOG_MESSAGE
* 日志信息。
*/
EVT_LOG_MESSAGE,
} event_base_type_t;
/**
* @class event_t
* @order -100
* @annotation ["scriptable"]
* 事件基类。
*/
typedef struct _event_t {
/**
* @property {uint32_t} type
* @annotation ["readable", "scriptable"]
* 类型。
*/
uint32_t type;
/**
* @property {uint32_t} size
* @annotation ["readable", "scriptable"]
* 结构体的大小。
*/
uint32_t size;
/**
* @property {uint64_t} time
* @annotation ["readable", "scriptable"]
* 事件发生的时间点（该时间点并非真实时间）。
*/
uint64_t time;
/**
* @property {void*} target
* @annotation ["readable", "scriptable"]
* 事件发生的目标对象。
*/
void* target;
/**
* @property {void*} native_window_handle
* @annotation ["readable"]
* 原生窗口句柄。
*/
void* native_window_handle;
} event_t;
/*事件处理函数原型*/
typedef ret_t (*event_func_t)(void* ctx, event_t* e);
/**
* @method event_cast
* 转换为event对象。
*
* > 供脚本语言使用
* @annotation ["cast", "scriptable"]
* @param {event_t*} event event对象。
*
* @return {event_t*} event对象。
*/
event_t* event_cast(event_t* event);
/**
* @method event_get_type
* 获取event类型。
* @annotation ["scriptable"]
* @param {event_t*} event event对象。
*
* @return {uint32_t} 返回event类型。
*/
uint32_t event_get_type(event_t* event);
/**
* @method event_create
* @annotation ["constructor", "scriptable", "gc"]
* 创建event对象。
*
* 主要给脚本语言使用。
* @param {uint32_t} type 事件类型。
*
* @return {event_t*} 返回事件对象。
*/
event_t* event_create(uint32_t type);
/**
* @method event_clone
* @annotation ["constructor"]
* clone事件对象。
*
* @param {event_t*} event event对象。
*
* @return {event_t*} 返回事件对象。
*/
event_t* event_clone(event_t* event);
/**
* @method event_destroy
* 销毁事件对象。
*
* 主要给脚本语言使用。
* @annotation ["deconstructor", "scriptable", "gc"]
* @param {event_t*} event event对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t event_destroy(event_t* event);
/**
* @method event_init
* 初始化事件。
* @annotation ["constructor"]
* @param {uint32_t} type 事件类型。
* @param {void*} target 目标对象。
*
* @return {event_t} 事件对象。
*/
event_t event_init(uint32_t type, void* target);
/**
* @class prop_change_event_t
* @annotation ["scriptable"]
* @parent event_t
* 对象属性变化事件。
*/
typedef struct _prop_change_event_t {
event_t e;
/**
* @property {const char*} name
* @annotation ["readable", "scriptable"]
* 属性的名称。
*/
const char* name;
/**
* @property {const value_t*} value
* @annotation ["readable", "scriptable"]
* 属性的值。
*/
const value_t* value;
} prop_change_event_t;
/**
* @method prop_change_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转prop_change_event_t对象。
* @param {event_t*} event event对象。
*
* @return {prop_change_event_t*} 返回event对象。
*/
prop_change_event_t* prop_change_event_cast(event_t* event);
/**
* @method prop_change_event_init
* 初始prop change event。
*
* @param {prop_change_event_t*} event event对象。
* @param {uint32_t} type 事件类型。
* @param {const char*} name 属性名。
* @param {const value_t*} value 属性的值。
*
* @return {event_t*} 返回event对象。
*/
event_t* prop_change_event_init(prop_change_event_t* event, uint32_t type, const char* name,
const value_t* value);
/**
* @class progress_event_t
* @annotation ["scriptable"]
* @parent event_t
* 进度变化事件。
*/
typedef struct _progress_event_t {
event_t e;
/**
* @property {uint32_t} percent
* @annotation ["readable", "scriptable"]
* 进度百分比。
*/
uint32_t percent;
} progress_event_t;
/**
* @method progress_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转progress_event_t对象。
* @param {event_t*} event event对象。
*
* @return {progress_event_t*} 返回event对象。
*/
progress_event_t* progress_event_cast(event_t* event);
/**
* @method progress_event_init
* 初始progress event。
*
* @param {progress_event_t*} event event对象。
* @param {uint32_t} percent 进度。
*
* @return {event_t*} 返回event对象。
*/
event_t* progress_event_init(progress_event_t* event, uint32_t percent);
/**
* @class done_event_t
* @annotation ["scriptable"]
* @parent event_t
* 执行完成事件。
*/
typedef struct _done_event_t {
event_t e;
/**
* @property {ret_t} result
* @annotation ["readable", "scriptable"]
* 执行结果。
*/
ret_t result;
} done_event_t;
/**
* @method done_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转done_event_t对象。
* @param {event_t*} event event对象。
*
* @return {done_event_t*} 返回event对象。
*/
done_event_t* done_event_cast(event_t* event);
/**
* @method done_event_init
* 初始done event。
*
* @param {done_event_t*} event event对象。
* @param {ret_t} result 结果。
*
* @return {event_t*} 返回event对象。
*/
event_t* done_event_init(done_event_t* event, ret_t result);
/**
* @class error_event_t
* @annotation ["scriptable"]
* @parent event_t
* 执行完成事件。
*/
typedef struct _error_event_t {
event_t e;
/**
* @property {int32_t} code
* @annotation ["readable", "scriptable"]
* 错误码。
*/
int32_t code;
/**
* @property {const char*} message
* @annotation ["readable", "scriptable"]
* 错误信息。
*/
const char* message;
} error_event_t;
/**
* @method error_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转error_event_t对象。
* @param {event_t*} event event对象。
*
* @return {error_event_t*} 返回event对象。
*/
error_event_t* error_event_cast(event_t* event);
/**
* @method error_event_init
* 初始error event。
*
* @param {error_event_t*} event event对象。
* @param {int32_t} code 错误码。
* @param {const char*} message 错误消息。
*
* @return {event_t*} 返回event对象。
*/
event_t* error_event_init(error_event_t* event, int32_t code, const char* message);
/**
* @class cmd_exec_event_t
* @annotation ["scriptable"]
* @parent event_t
* 对象执行命令的事件。
*/
typedef struct _cmd_exec_event_t {
event_t e;
/**
* @property {const char*} name
* @annotation ["readable", "scriptable"]
* 命令的名称。
*/
const char* name;
/**
* @property {const char*} args
* @annotation ["readable", "scriptable"]
* 命令的参数。
*/
const char* args;
/**
* @property {ret_t} result
* @annotation ["readable", "scriptable"]
* 执行结果(适用于EXECED)。
*/
ret_t result;
/**
* @property {bool_t} can_exec
* @annotation ["readable", "scriptable"]
* 标识命令是否可以执行(适用于CAN_EXEC)。
*/
bool_t can_exec;
} cmd_exec_event_t;
/**
* @method cmd_exec_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转cmd_exec_event_t对象。
* @param {event_t*} event event对象。
*
* @return {cmd_exec_event_t*} 返回event对象。
*/
cmd_exec_event_t* cmd_exec_event_cast(event_t* event);
/**
* @method cmd_exec_event_init
* 初始命令执行事件。
*
* @param {cmd_exec_event_t*} event event对象。
* @param {uint32_t} type 事件类型。
* @param {const char*} name 命令名。
* @param {const char*} args 命令参数。
*
* @return {event_t*} 返回event对象。
*/
event_t* cmd_exec_event_init(cmd_exec_event_t* event, uint32_t type, const char* name,
const char* args);
/**
* @class value_change_event_t
* @annotation ["scriptable"]
* @parent event_t
* 值变化事件。
*/
typedef struct _value_change_event_t {
event_t e;
/**
* @property {value_t} old_value
* @annotation ["readable"]
* 旧值。
*/
value_t old_value;
/**
* @property {value_t} new_value
* @annotation ["readable"]
* 新值。
*/
value_t new_value;
} value_change_event_t;
/**
* @method value_change_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转value_change_event_t对象。
* @param {event_t*} event event对象。
*
* @return {value_change_event_t*} event对象。
*/
value_change_event_t* value_change_event_cast(event_t* event);
/**
* @method value_change_event_init
* 初始化事件。
* @param {value_change_event_t*} event event对象。
* @param {uint32_t} type 事件类型。
* @param {void*} target 事件目标。
*
* @return {event_t*} event对象。
*/
event_t* value_change_event_init(value_change_event_t* event, uint32_t type, void* target);
/**
* @class log_message_event_t
* @annotation ["scriptable"]
* @parent event_t
* 日志事件。
*/
typedef struct _log_message_event_t {
event_t e;
/**
* @property {tk_log_level_t} level
* @annotation ["readable"]
* 级别。
*/
tk_log_level_t level;
/**
* @property {const char*} message
* @annotation ["readable"]
* 日志。
*/
const char* message;
} log_message_event_t;
/**
* @method log_message_event_cast
* @annotation ["cast", "scriptable"]
* 把event对象转log_message_event_t对象。
* @param {event_t*} event event对象。
*
* @return {log_message_event_t*} event对象。
*/
log_message_event_t* log_message_event_cast(event_t* event);
/**
* @method log_message_event_init
* 初始化事件。
* @param {log_message_event_t*} event event对象。
* @param {tk_log_level_t} level 级别。
* @param {const char*} message 日志。
*
* @return {event_t*} event对象。
*/
event_t* log_message_event_init(log_message_event_t* event, tk_log_level_t level,
const char* message);
END_C_DECLS
#endif /**TK_EVENT_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_date_time.c
|
/**
* File: object_date_time.c
* Author: AWTK Develop Team
* Brief: wrap typed array to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "tkc/named_value.h"
#include "object_date_time.h"
static ret_t object_date_time_on_destroy(tk_object_t* obj) {
object_date_time_t* o = OBJECT_DATE_TIME(obj);
return_value_if_fail(o != NULL && o->dt != NULL, RET_BAD_PARAMS);
date_time_destroy(o->dt);
o->dt = NULL;
return RET_OK;
}
static ret_t object_date_time_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
ret_t ret = RET_OK;
object_date_time_t* o = OBJECT_DATE_TIME(obj);
return_value_if_fail(o != NULL && o->dt != NULL, RET_BAD_PARAMS);
switch (*name) {
case 'y': {
date_time_set_year(o->dt, value_uint32(v));
break;
}
case 'm': {
if (name[1] == 'i') {
date_time_set_minute(o->dt, value_uint32(v));
} else {
date_time_set_month(o->dt, value_uint32(v));
}
break;
}
case 'd': {
date_time_set_day(o->dt, value_uint32(v));
break;
}
case 'h': {
date_time_set_hour(o->dt, value_uint32(v));
break;
}
case 's': {
date_time_set_second(o->dt, value_uint32(v));
break;
}
case 'w': {
/*日期确定后，wday也确定了，支持设置wday方便测试检查结果*/
o->dt->wday = value_uint32(v);
break;
}
default: {
ret = RET_NOT_FOUND;
}
}
return ret;
}
static ret_t object_date_time_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_OK;
object_date_time_t* o = OBJECT_DATE_TIME(obj);
return_value_if_fail(o != NULL && o->dt != NULL, RET_BAD_PARAMS);
switch (*name) {
case 'y': {
value_set_uint32(v, o->dt->year);
break;
}
case 'm': {
if (name[1] == 'i') {
value_set_uint32(v, o->dt->minute);
} else {
value_set_uint32(v, o->dt->month);
}
break;
}
case 'd': {
value_set_uint32(v, o->dt->day);
break;
}
case 'h': {
value_set_uint32(v, o->dt->hour);
break;
}
case 's': {
value_set_uint32(v, o->dt->second);
break;
}
case 'w': {
value_set_uint32(v, o->dt->wday);
break;
}
default: {
ret = RET_NOT_FOUND;
}
}
return ret;
}
static ret_t object_date_time_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
named_value_t nv;
ret_t ret = RET_OK;
object_date_time_t* o = OBJECT_DATE_TIME(obj);
return_value_if_fail(on_prop != NULL, RET_BAD_PARAMS);
return_value_if_fail(o != NULL && o->dt != NULL, RET_BAD_PARAMS);
nv.name = OBJECT_DATE_TIME_PROP_YEAR;
value_set_uint32(&(nv.value), o->dt->year);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
nv.name = OBJECT_DATE_TIME_PROP_MONTH;
value_set_uint32(&(nv.value), o->dt->month);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
nv.name = OBJECT_DATE_TIME_PROP_MINUTE;
value_set_uint32(&(nv.value), o->dt->minute);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
nv.name = OBJECT_DATE_TIME_PROP_DAY;
value_set_uint32(&(nv.value), o->dt->day);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
nv.name = OBJECT_DATE_TIME_PROP_HOUR;
value_set_uint32(&(nv.value), o->dt->hour);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
nv.name = OBJECT_DATE_TIME_PROP_SECOND;
value_set_uint32(&(nv.value), o->dt->second);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
nv.name = OBJECT_DATE_TIME_PROP_WDAY;
value_set_uint32(&(nv.value), o->dt->wday);
ret = on_prop(ctx, &nv);
return_value_if_fail(ret == RET_OK, RET_FAIL);
return RET_OK;
}
static const object_vtable_t s_object_date_time_vtable = {
.type = OBJECT_DATE_TIME_TYPE,
.desc = OBJECT_DATE_TIME_TYPE,
.size = sizeof(object_date_time_t),
.is_collection = FALSE,
.on_destroy = object_date_time_on_destroy,
.foreach_prop = object_date_time_foreach_prop,
.get_prop = object_date_time_get_prop,
.set_prop = object_date_time_set_prop};
tk_object_t* object_date_time_create(void) {
tk_object_t* o = NULL;
object_date_time_t* wrapper = NULL;
o = tk_object_create(&s_object_date_time_vtable);
return_value_if_fail(o != NULL, NULL);
wrapper = OBJECT_DATE_TIME(o);
return_value_if_fail(wrapper != NULL, NULL);
wrapper->dt = date_time_create();
if (wrapper->dt == NULL) {
TK_OBJECT_UNREF(o);
}
return o;
}
object_date_time_t* object_date_time_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_date_time_vtable, NULL);
return (object_date_time_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/named_value.c
|
/**
* File: named_value.c
* Author: AWTK Develop Team
* Brief: named value
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-10 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/named_value.h"
named_value_t* named_value_cast(named_value_t* nv) {
return_value_if_fail(nv != NULL, NULL);
return nv;
}
named_value_t* named_value_init(named_value_t* nv, const char* name, const value_t* value) {
return_value_if_fail(nv != NULL, NULL);
memset(nv, 0x00, sizeof(named_value_t));
if (name != NULL) {
named_value_set_name(nv, name);
}
if (value != NULL) {
named_value_set_value(nv, value);
}
return nv;
}
named_value_t* named_value_create(void) {
named_value_t* nv = TKMEM_ZALLOC(named_value_t);
return_value_if_fail(nv != NULL, NULL);
return named_value_init(nv, NULL, NULL);
}
#define TK_EXTRA_DATA(obj) (((char*)(obj)) + sizeof(*obj))
named_value_t* named_value_create_ex(const char* name, const value_t* value) {
char* p = NULL;
named_value_t* nv = NULL;
uint32_t slen = tk_strlen(name) + 1;
return_value_if_fail(name != NULL && value != NULL, NULL);
nv = (named_value_t*)TKMEM_ALLOC(sizeof(named_value_t) + slen);
return_value_if_fail(nv != NULL, NULL);
memset(nv, 0x00, sizeof(named_value_t));
p = TK_EXTRA_DATA(nv);
memcpy(p, name, slen);
nv->name = p;
named_value_set_value(nv, value);
return nv;
}
ret_t named_value_set_name(named_value_t* nv, const char* name) {
const char* p = NULL;
return_value_if_fail(nv != NULL, RET_BAD_PARAMS);
p = TK_EXTRA_DATA(nv);
if (p != nv->name) {
nv->name = tk_str_copy(nv->name, name);
} else {
nv->name = tk_strdup(name);
}
return RET_OK;
}
ret_t named_value_set_value(named_value_t* nv, const value_t* value) {
return_value_if_fail(nv != NULL && value != NULL, RET_BAD_PARAMS);
if (value_equal(&(nv->value), value)) {
return RET_OK;
}
if (!value_equal(value, &(nv->value))) {
value_reset(&(nv->value));
return value_deep_copy(&(nv->value), value);
}
return RET_OK;
}
ret_t named_value_deinit(named_value_t* nv) {
char* p = NULL;
return_value_if_fail(nv != NULL, RET_BAD_PARAMS);
p = TK_EXTRA_DATA(nv);
if (p != nv->name) {
TKMEM_FREE(nv->name);
}
value_reset(&(nv->value));
return RET_OK;
}
ret_t named_value_destroy(named_value_t* nv) {
return_value_if_fail(nv != NULL, RET_BAD_PARAMS);
named_value_deinit(nv);
TKMEM_FREE(nv);
return RET_OK;
}
value_t* named_value_get_value(named_value_t* nv) {
return_value_if_fail(nv != NULL, NULL);
return &(nv->value);
}
int32_t named_value_compare_by_name(named_value_t* nv, const char* name) {
return_value_if_fail(nv != NULL && name != NULL, -1);
return tk_str_cmp(nv->name, name);
}
int32_t named_value_compare(named_value_t* nv, const named_value_t* other) {
return_value_if_fail(nv != NULL && other != NULL, -1);
return tk_str_cmp(nv->name, other->name);
}
int32_t named_value_icompare(named_value_t* nv, const named_value_t* other) {
return_value_if_fail(nv != NULL && other != NULL, -1);
return tk_stricmp(nv->name, other->name);
}
int32_t named_value_icompare_by_name(named_value_t* nv, const char* name) {
return_value_if_fail(nv != NULL && name != NULL, -1);
return tk_stricmp(nv->name, name);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mutex.h
|
/**
* File: mutex.h
* Author: AWTK Develop Team
* Brief: mutex
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-05-18 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MUTEX_H
#define TK_MUTEX_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class tk_mutex_t
* 互斥锁。
*/
struct _tk_mutex_t;
typedef struct _tk_mutex_t tk_mutex_t;
/**
* @method tk_mutex_create
* 创建mutex。
*
* @return {tk_mutex_t*} mutex对象。
*/
tk_mutex_t* tk_mutex_create(void);
/**
* @method tk_mutex_lock
* 加锁。
* @param {tk_mutex_t*} mutex mutex对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_lock(tk_mutex_t* mutex);
/**
* @method tk_mutex_try_lock
* 尝试加锁。
* @param {tk_mutex_t*} mutex mutex对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_try_lock(tk_mutex_t* mutex);
/**
* @method tk_mutex_unlock
* 解锁。
* @param {tk_mutex_t*} mutex mutex对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_unlock(tk_mutex_t* mutex);
/**
* @method tk_mutex_destroy
* 销毁mutex对象。
* @param {tk_mutex_t*} mutex mutex对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mutex_destroy(tk_mutex_t* mutex);
END_C_DECLS
#endif /*TK_MUTEX_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_idle.h
|
/**
* File: event_source_idle.h
* Author: AWTK Develop Team
* Brief: event source idle
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EVENT_SOURCE_IDLE_H
#define TK_EVENT_SOURCE_IDLE_H
#include "tkc/event_source.h"
#include "tkc/idle_manager.h"
BEGIN_C_DECLS
struct _event_source_idle_t;
typedef struct _event_source_idle_t event_source_idle_t;
/**
* @class event_source_idle_t
* @parent tk_object_t
*
* idle事件源。
*
*/
struct _event_source_idle_t {
event_source_t event_source;
idle_manager_t* idle_manager;
};
/**
* @method event_source_idle_create
*
* 创建idle事件源。
*
* @param {idle_manager_t*} idle_manager 定时器管理器对象。
*
* @return {event_source_t*} 返回事件源对象。
*
*/
event_source_t* event_source_idle_create(idle_manager_t* idle_manager);
#define EVENT_SOURCE_IDLE(obj) ((event_source_idle_t*)(obj))
END_C_DECLS
#endif /*TK_EVENT_SOURCE_IDLE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/qaction.c
|
/**
* File: qaction.c
* Author: AWTK Develop Team
* Brief: qaction
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-06 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/qaction.h"
qaction_t* qaction_create(qaction_exec_t exec, void* args, uint32_t args_size) {
qaction_t* action = NULL;
uint32_t size = sizeof(qaction_t) + args_size;
return_value_if_fail(exec != NULL, NULL);
action = TKMEM_ALLOC(size);
return_value_if_fail(action != NULL, NULL);
memset(action, 0x00, size);
action->exec = exec;
if (args != NULL) {
memcpy(action->args, args, args_size);
}
return action;
}
ret_t qaction_set_on_event(qaction_t* action, qaction_on_event_t on_event) {
return_value_if_fail(action != NULL, RET_BAD_PARAMS);
action->on_event = on_event;
return RET_OK;
}
ret_t qaction_notify(qaction_t* action, event_t* event) {
return_value_if_fail(action != NULL && event != NULL, RET_BAD_PARAMS);
if (action->on_event != NULL) {
return action->on_event(action, event);
}
return RET_NOT_IMPL;
}
ret_t qaction_exec(qaction_t* action) {
return_value_if_fail(action != NULL && action->exec != NULL, RET_BAD_PARAMS);
return action->exec(action);
}
ret_t qaction_destroy(qaction_t* q) {
return_value_if_fail(q != NULL, RET_BAD_PARAMS);
memset(q, 0x00, sizeof(qaction_t));
TKMEM_FREE(q);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/rlog.h
|
/**
* File: rlog.h
* Author: AWTK Develop Team
* Brief: rotate log api
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-11-18 Li XianJing <[email protected]> created
*
*/
#ifndef TK_RLOG_H
#define TK_RLOG_H
#include "tkc/fs.h"
#include "tkc/mutex_nest.h"
BEGIN_C_DECLS
/**
* @class rlog_t
* @annotation ["scriptable"]
* 循环记录日志(支持多线程访问)。
* 如果我们把日志写入文件中，随着时间的推移，日志文件会越来越大，最终占满这个磁盘，出现不可预料的错误。
* rlog提供一个循环记录日志的功能，让日志文件始终不会超出指定的大小，达到指定大小后再从头开始写。
*
* > 为了实现简单，我们把日志文件分成0和1两个文件，先写文件0，到达指定最大值的一半时，再写文件1。
* > 文件1到达指定最大值的一半时，删除文件0，并将文件1改名为文件0，重新创建文件1，继续写文件1，重复此过程。
*/
typedef struct _rlog_t {
/*private*/
fs_file_t* fp;
char* buff;
char* filename_pattern;
uint32_t index;
uint32_t max_size;
uint32_t buff_size;
tk_mutex_nest_t* mutex;
} rlog_t;
/**
* @method rlog_create
* 创建rlog对象。
*
* ```c
* rlog_t* log = rlog_create("./logs/%d.log", 1020*1024, 256);
* rlog_write(log, "hello\n");
* rlog_destroy(log);
* ```
*
* @annotation ["scriptable", "constructor"]
* @param {const char*} filename_pattern 用来确定文件名的路径和文件名。
* @param {uint32_t} max_size log文件占用最大磁盘空间(字节)。
* @param {uint32_t} buff_size 用于指定print时的buff大小。
*
* @return {rlog_t*} 返回rlog对象。
*/
rlog_t* rlog_create(const char* filename_pattern, uint32_t max_size, uint32_t buff_size);
/**
* @method rlog_write
* 写入一条日志记录。
*
* @annotation ["scriptable"]
* @param {rlog_t*} log 日志对象。
* @param {const char*} str 日志字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rlog_write(rlog_t* log, const char* str);
/**
* @method rlog_print
* 写入一条日志记录。
*
* @param {rlog_t*} log 日志对象。
* @param {const char*} format 格式字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rlog_print(rlog_t* log, const char* format, ...);
/**
* @method rlog_destroy
* 销毁日志对象。
*
* @param {rlog_t*} log 日志对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rlog_destroy(rlog_t* log);
/**
* @method rlog_size
* 获取日志大小。
*
* @param {rlog_t*} log 日志对象。
* @param {uint32_t*} size 获取的日志大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rlog_size(rlog_t* log, uint32_t* size);
/**
* @method rlog_clear
* 清空日志。
*
* @param {rlog_t*} log 日志对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rlog_clear(rlog_t* log);
/**
* @method rlog_read
* 读取日志。
*
* @param {rlog_t*} log 日志对象。
* @param {uint32_t} offs 日志偏移量。
* @param {char*} buff 存放日志的缓存。
* @param {uint32_t} buffsz 缓存大小。
* @param {uint32_t*} readsz 读取出的日志大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t rlog_read(rlog_t* log, uint32_t offs, char* buff, uint32_t buffsz, uint32_t* readsz);
END_C_DECLS
#endif /*TK_RLOG_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/sha256.c
|
/*
* SHA-256 implementation.
*
* Copyright (c) 2010 Ilya O. Levin, http://www.literatecode.com
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* adapted from https://raw.githubusercontent.com/ilvn/SHA256/main/sha256.c
*/
#define SWAP_BYTES
// #define USE_STD_MEMCPY
// #define SELF_TEST
#include "sha256.h"
#include "tkc/utils.h"
#ifdef __cplusplus
extern "C" {
#endif
#define RL(x, n) (((x) << n) | ((x) >> (32 - n)))
#define RR(x, n) (((x) >> n) | ((x) << (32 - n)))
#define S0(x) (RR((x), 2) ^ RR((x), 13) ^ RR((x), 22))
#define S1(x) (RR((x), 6) ^ RR((x), 11) ^ RR((x), 25))
#define G0(x) (RR((x), 7) ^ RR((x), 18) ^ ((x) >> 3))
#define G1(x) (RR((x), 17) ^ RR((x), 19) ^ ((x) >> 10))
#ifdef SWAP_BYTES
#define BSWP(x, y) _bswapw((uint32_t*)(x), (uint32_t)(y))
#else
#define BSWP(p, n)
#endif
#ifdef USE_STD_MEMCPY
#define MEMCP(x, y, z) memcpy((x), (y), (z))
#else
#define MEMCP(x, y, z) _memcp((x), (y), (z))
#endif
#ifndef __cdecl
#define __cdecl
#endif
static const uint32_t K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
/* -------------------------------------------------------------------------- */
static void _bswapw(uint32_t* p, uint32_t i) {
while (i--) p[i] = (RR(p[i], 24) & 0x00ff00ff) | (RR(p[i], 8) & 0xff00ff00);
} /* _bswapw */
/* -------------------------------------------------------------------------- */
#ifndef USE_STD_MEMCPY
void* __cdecl _memcp(void* d, const void* s, uint32_t sz) {
void* rv = d;
while (sz--) *(char*)d = *(char*)s, d = (char*)d + 1, s = (char*)s + 1;
return (rv);
} /* _memcp */
#endif
/* -------------------------------------------------------------------------- */
static void _rtrf(uint32_t* b, uint32_t* p, uint32_t i, uint32_t j) {
#define B(x, y) b[(x - y) & 7]
#define P(x, y) p[(x + y) & 15]
B(7, i) += (j ? (p[i & 15] += G1(P(i, 14)) + P(i, 9) + G0(P(i, 1))) : p[i & 15]) + K[i + j] +
S1(B(4, i)) + (B(6, i) ^ (B(4, i) & (B(5, i) ^ B(6, i))));
B(3, i) += B(7, i);
B(7, i) += S0(B(0, i)) + ((B(0, i) & B(1, i)) | (B(2, i) & (B(0, i) ^ B(1, i))));
#undef P
#undef B
} /* _rtrf */
/* -------------------------------------------------------------------------- */
static void _hash(tk_sha256_t* ctx) {
uint32_t b[8], *p, j;
b[0] = ctx->hash[0];
b[1] = ctx->hash[1];
b[2] = ctx->hash[2];
b[3] = ctx->hash[3];
b[4] = ctx->hash[4];
b[5] = ctx->hash[5];
b[6] = ctx->hash[6];
b[7] = ctx->hash[7];
for (p = ctx->buf, j = 0; j < 64; j += 16)
_rtrf(b, p, 0, j), _rtrf(b, p, 1, j), _rtrf(b, p, 2, j), _rtrf(b, p, 3, j), _rtrf(b, p, 4, j),
_rtrf(b, p, 5, j), _rtrf(b, p, 6, j), _rtrf(b, p, 7, j), _rtrf(b, p, 8, j),
_rtrf(b, p, 9, j), _rtrf(b, p, 10, j), _rtrf(b, p, 11, j), _rtrf(b, p, 12, j),
_rtrf(b, p, 13, j), _rtrf(b, p, 14, j), _rtrf(b, p, 15, j);
ctx->hash[0] += b[0];
ctx->hash[1] += b[1];
ctx->hash[2] += b[2];
ctx->hash[3] += b[3];
ctx->hash[4] += b[4];
ctx->hash[5] += b[5];
ctx->hash[6] += b[6];
ctx->hash[7] += b[7];
} /* _hash */
/* -------------------------------------------------------------------------- */
static void sha256_init(tk_sha256_t* ctx) {
ctx->len[0] = ctx->len[1] = 0;
ctx->hash[0] = 0x6a09e667;
ctx->hash[1] = 0xbb67ae85;
ctx->hash[2] = 0x3c6ef372;
ctx->hash[3] = 0xa54ff53a;
ctx->hash[4] = 0x510e527f;
ctx->hash[5] = 0x9b05688c;
ctx->hash[6] = 0x1f83d9ab;
ctx->hash[7] = 0x5be0cd19;
} /* sha256_init */
/* -------------------------------------------------------------------------- */
static void sha256_hash(tk_sha256_t* ctx, uint8_t* dat, uint32_t sz) {
register uint32_t i = ctx->len[0] & 63, l, j;
if ((ctx->len[0] += sz) < sz) ++(ctx->len[1]);
for (j = 0, l = 64 - i; sz >= l; j += l, sz -= l, l = 64, i = 0) {
MEMCP((char*)ctx->buf + i, &dat[j], l);
BSWP(ctx->buf, 16);
_hash(ctx);
}
MEMCP((char*)ctx->buf + i, &dat[j], sz);
} /* _hash */
/* -------------------------------------------------------------------------- */
static void sha256_done(tk_sha256_t* ctx, uint8_t* buf) {
uint32_t i = (uint32_t)(ctx->len[0] & 63), j = ((~i) & 3) << 3;
BSWP(ctx->buf, (i + 3) >> 2);
ctx->buf[i >> 2] &= 0xffffff80 << j; /* add padding */
ctx->buf[i >> 2] |= 0x00000080 << j;
if (i < 56)
i = (i >> 2) + 1;
else
ctx->buf[15] ^= (i < 60) ? ctx->buf[15] : 0, _hash(ctx), i = 0;
while (i < 14) ctx->buf[i++] = 0;
ctx->buf[14] = (ctx->len[1] << 3) | (ctx->len[0] >> 29); /* add length */
ctx->buf[15] = ctx->len[0] << 3;
_hash(ctx);
for (i = 0; i < 32; i++)
ctx->buf[i % 16] = 0, /* may remove this line in case of a DIY cleanup */
buf[i] = (uint8_t)(ctx->hash[i >> 2] >> ((~i & 3) << 3));
} /* sha256_done */
ret_t tk_sha256_init(tk_sha256_t* sha256) {
return_value_if_fail(sha256 != NULL, RET_BAD_PARAMS);
sha256_init(sha256);
return RET_OK;
}
ret_t tk_sha256_hash(tk_sha256_t* sha256, const uint8_t* data, uint32_t len) {
return_value_if_fail(sha256 != NULL && data != NULL, RET_BAD_PARAMS);
sha256_hash(sha256, (uint8_t*)data, len);
return RET_OK;
}
ret_t tk_sha256_done(tk_sha256_t* sha256, uint8_t hash[TK_SHA256_HASH_LEN + 1]) {
return_value_if_fail(sha256 != NULL && hash != NULL, RET_BAD_PARAMS);
sha256_done(sha256, (uint8_t*)hash);
return RET_OK;
}
static ret_t tk_sha256_hash_to_str(str_t* hash, uint8_t result[TK_SHA256_HASH_LEN + 1]) {
char text[32];
uint32_t i = 0;
for (i = 0; i < TK_SHA256_HASH_LEN; i++) {
tk_snprintf(text, sizeof(text), "%02x", (int)(result[i]));
str_append(hash, text);
}
return RET_OK;
}
ret_t tk_sha256(const void* data, uint32_t len, str_t* hash) {
tk_sha256_t sha256;
uint8_t result[TK_SHA256_HASH_LEN + 1];
return_value_if_fail(data != NULL && hash != NULL, RET_BAD_PARAMS);
tk_sha256_init(&sha256);
tk_sha256_hash(&sha256, (const uint8_t*)data, len);
tk_sha256_done(&sha256, result);
return tk_sha256_hash_to_str(hash, result);
}
#include "tkc/fs.h"
#include "tkc/mem.h"
ret_t tk_sha256_file(const char* filename, uint32_t block_size, str_t* hash) {
int32_t size = 0;
ret_t ret = RET_FAIL;
fs_file_t* fp = NULL;
uint8_t* buff = NULL;
tk_sha256_t sha256;
uint8_t result[TK_SHA256_HASH_LEN + 1];
return_value_if_fail(filename != NULL && hash != NULL, RET_BAD_PARAMS);
fp = fs_open_file(os_fs(), filename, "rb");
return_value_if_fail(fp != NULL, RET_BAD_PARAMS);
block_size = tk_max_int(block_size, 256);
block_size = tk_min_int(block_size, 1024 * 1024);
buff = TKMEM_ALLOC(block_size + 1);
goto_error_if_fail(buff != NULL);
tk_sha256_init(&sha256);
while (!fs_file_eof(fp)) {
size = fs_file_read(fp, buff, block_size);
if (size <= 0) {
break;
}
tk_sha256_hash(&sha256, buff, size);
}
tk_sha256_done(&sha256, result);
ret = tk_sha256_hash_to_str(hash, result);
error:
fs_file_close(fp);
TKMEM_FREE(buff);
return ret;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/cmd_args.h
|
/**
* File: cmd_args.h
* Author: AWTK Develop Team
* Brief: command line args parser
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2023-04-14 Li XianJing <[email protected]> created
*
*/
#ifndef TK_CMD_ARGS_H
#define TK_CMD_ARGS_H
#include "tkc/str.h"
BEGIN_C_DECLS
/**
* @class cmd_arg_desc_t
* 参数描述。
*/
typedef struct _cmd_arg_desc_t {
/**
* @property {const char*} name
* @annotation ["readable"]
* 名称。
*/
const char* name;
/**
* @property {const char*} desc
* @annotation ["readable"]
* 描述。
*/
const char* desc;
/**
* @property {const char*} short_name
* @annotation ["readable"]
* 缩写。
*/
const char* short_name;
/**
* @property {value_type_t} value_type
* @annotation ["readable"]
* 数据类型。
*/
value_type_t value_type;
} cmd_arg_desc_t;
typedef ret_t (*cmd_arg_on_arg_t)(void* ctx, const char* name, const value_t* v);
/**
* @class cmd_args_t
* 命令行处理。
*/
typedef struct _cmd_args_t {
/*private*/
const char* usage;
void* on_arg_ctx;
cmd_arg_on_arg_t on_arg;
const cmd_arg_desc_t* desc;
uint32_t desc_nr;
} cmd_args_t;
/**
* @method cmd_args_init
* 初始化。
*
* @param {cmd_args_t*} args args对象。
* @param {const char*} usage 帮助信息。
* @param {const cmd_arg_desc_t*} desc 参数描述。
* @param {uint32_t} desc_nr 参数描述个数。
* @param {cmd_arg_on_arg_t} on_arg 参数处理回调函数。
* @param {void*} on_arg_ctx 参数处理回调函数的上下文。
*
* @return {cmd_args_t*} 返回CMD_ARGS对象。
*/
cmd_args_t* cmd_args_init(cmd_args_t* args, const char* usage, const cmd_arg_desc_t* desc,
uint32_t desc_nr, cmd_arg_on_arg_t on_arg, void* on_arg_ctx);
/**
* @method cmd_args_show_help
* 显示帮助信息。
*
* @param {cmd_args_t*} args args对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t cmd_args_show_help(cmd_args_t* args);
/**
* @method cmd_args_process
* 处理。
*
* @param {cmd_args_t*} args args对象。
* @param {int} argc 参数个数。
* @param {char**} argv 参数数组。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t cmd_args_process(cmd_args_t* args, int argc, char* argv[]);
/**
* @method cmd_args_process_wstr
* 处理。
*
* @param {cmd_args_t*} args args对象。
* @param {int} argc 参数个数。
* @param {wchar_t**} argv 参数数组。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t cmd_args_process_wstr(cmd_args_t* args, int argc, wchar_t* argv[]);
/**
* @method cmd_args_process_str
* 处理。
*
* @param {cmd_args_t*} args args对象。
* @param {const char*} cmd_line 字符串格式的参数(适用于Windows)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t cmd_args_process_str(cmd_args_t* args, const char* cmd_line);
END_C_DECLS
#endif /*TK_CMD_ARGS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/str.c
|
/**
* File: str.c
* Author: AWTK Develop Team
* Brief: string
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-30 Li XianJing <[email protected]> adapt from uclib
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/str.h"
#include "tkc/utils.h"
#include "tkc/value.h"
#include "tkc/object.h"
#include "tkc/tokenizer.h"
str_t* str_create(uint32_t capacity) {
str_t* str = TKMEM_ZALLOC(str_t);
return_value_if_fail(str != NULL, NULL);
return str_init(str, capacity);
}
ret_t str_destroy(str_t* str) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
str_reset(str);
TKMEM_FREE(str);
return RET_OK;
}
ret_t str_extend(str_t* str, uint32_t capacity) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
if (capacity <= str->capacity) {
return RET_OK;
}
if (!str->extendable) {
return RET_FAIL;
}
if (capacity > 0) {
char* s = TKMEM_REALLOCT(char, str->str, capacity + 1);
return_value_if_fail(s != NULL, RET_FAIL);
s[capacity] = '\0';
str->str = s;
str->capacity = capacity;
memset(s + str->size, 0x00, capacity + 1 - str->size);
}
return RET_OK;
}
ret_t str_shrink(str_t* str, uint32_t size) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
if (size < str->size) {
str->size = size;
str->str[size] = '\0';
}
return RET_OK;
}
str_t* str_init(str_t* str, uint32_t capacity) {
return_value_if_fail(str != NULL, NULL);
memset(str, 0x00, sizeof(str_t));
str->extendable = TRUE;
return str_extend(str, capacity) == RET_OK ? str : NULL;
}
str_t* str_attach_with_size(str_t* str, char* buff, uint32_t size, uint32_t capacity) {
return_value_if_fail(str != NULL && buff != NULL && capacity > 0, NULL);
return_value_if_fail(size < capacity, NULL);
memset(str, 0x00, sizeof(str_t));
str->str = buff;
str->size = size;
str->capacity = capacity;
str->extendable = FALSE;
buff[size] = '\0';
return str;
}
str_t* str_attach(str_t* str, char* buff, uint32_t capacity) {
return_value_if_fail(str != NULL && buff != NULL && capacity > 0, NULL);
memset(str, 0x00, sizeof(str_t));
memset(buff, 0x00, capacity);
return str_attach_with_size(str, buff, 0, capacity);
}
ret_t str_set(str_t* str, const char* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return str_set_with_len(str, text, tk_strlen(text));
}
ret_t str_clear(str_t* str) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
str->size = 0;
if (str->str != NULL) {
str->str[0] = '\0';
}
return RET_OK;
}
ret_t str_set_with_len(str_t* str, const char* text, uint32_t len) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, len + 1) == RET_OK, RET_BAD_PARAMS);
tk_strncpy(str->str, text, len);
str->size = len;
str->str[str->size] = '\0';
str->size = tk_strlen(str->str);
return RET_OK;
}
ret_t str_append_with_len(str_t* str, const char* text, uint32_t size) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, str->size + size + 1) == RET_OK, RET_BAD_PARAMS);
memcpy(str->str + str->size, text, size);
str->size += size;
str->str[str->size] = '\0';
return RET_OK;
}
ret_t str_append(str_t* str, const char* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return str_append_with_len(str, text, strlen(text));
}
ret_t str_append_uppercase(str_t* str, const char* text) {
ret_t ret = RET_OK;
const char* p = text;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
while (*p) {
ret = str_append_char(str, toupper(*p));
break_if_fail(ret == RET_OK);
p++;
}
return ret;
}
ret_t str_append_lowercase(str_t* str, const char* text) {
ret_t ret = RET_OK;
const char* p = text;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
while (*p) {
ret = str_append_char(str, tolower(*p));
break_if_fail(ret == RET_OK);
p++;
}
return ret;
}
ret_t str_append_more(str_t* str, const char* text, ...) {
va_list va;
const char* p = NULL;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append(str, text) == RET_OK, RET_OOM);
va_start(va, text);
do {
p = va_arg(va, char*);
if (p != NULL) {
return_value_if_fail(str_append(str, p) == RET_OK, RET_OOM);
} else {
break;
}
} while (p != NULL);
va_end(va);
return RET_OK;
}
ret_t str_append_int(str_t* str, int32_t value) {
char num[32] = {0};
tk_snprintf(num, sizeof(num) - 1, "%d", value);
return str_append(str, num);
}
ret_t str_append_uint32(str_t* str, uint32_t value) {
char num[32] = {0};
tk_snprintf(num, sizeof(num) - 1, "%u", value);
return str_append(str, num);
}
ret_t str_append_int64(str_t* str, int64_t value) {
char num[64] = {0};
tk_snprintf(num, sizeof(num) - 1, "%" PRId64, value);
return str_append(str, num);
}
ret_t str_append_uint64(str_t* str, uint64_t value) {
char num[64] = {0};
tk_snprintf(num, sizeof(num) - 1, "%" PRIu64, value);
return str_append(str, num);
}
ret_t str_from_int64(str_t* str, int64_t value) {
char num[64] = {0};
tk_snprintf(num, sizeof(num) - 1, "%" PRId64, value);
return str_set(str, num);
}
ret_t str_from_uint64(str_t* str, uint64_t value) {
char num[64] = {0};
tk_snprintf(num, sizeof(num) - 1, "%" PRIu64, value);
return str_set(str, num);
}
ret_t str_append_char(str_t* str, char c) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, str->size + 2) == RET_OK, RET_BAD_PARAMS);
str->str[str->size++] = c;
str->str[str->size] = '\0';
return RET_OK;
}
ret_t str_append_n_chars(str_t* str, char c, uint32_t n) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, str->size + n + 1) == RET_OK, RET_BAD_PARAMS);
memset(str->str + str->size, c, n);
str->size += n;
str->str[str->size] = '\0';
return RET_OK;
}
ret_t str_decode_xml_entity_with_len(str_t* str, const char* text, uint32_t len) {
char* d = NULL;
const char* s = text;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, len + 1) == RET_OK, RET_OOM);
d = str->str;
str->size = 0;
while (*s && (s - text) < len) {
char c = *s++;
if (c == '&') {
if (strncmp(s, "lt;", 3) == 0) {
c = '<';
s += 3;
} else if (strncmp(s, "gt;", 3) == 0) {
c = '>';
s += 3;
} else if (strncmp(s, "amp;", 4) == 0) {
c = '&';
s += 4;
} else if (strncmp(s, "quot;", 5) == 0 || strncmp(s, "quota;", 6) == 0) {
c = '\"';
s += 5;
} else if (strncmp(s, "nbsp;", 5) == 0) {
c = ' ';
s += 5;
}
}
*d++ = c;
}
*d = '\0';
str->size = d - str->str;
return RET_OK;
}
ret_t str_decode_xml_entity(str_t* str, const char* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return str_decode_xml_entity_with_len(str, text, strlen(text));
}
ret_t str_encode_xml_entity(str_t* str, const char* text) {
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
return str_encode_xml_entity_with_len(str, text, strlen(text));
}
ret_t str_encode_xml_entity_with_len(str_t* str, const char* text, uint32_t len) {
uint32_t i = 0;
return_value_if_fail(str != NULL && text != NULL, RET_BAD_PARAMS);
for (i = 0; i < len; i++) {
char c = text[i];
switch (c) {
case '<': {
return_value_if_fail(str_append(str, "<") == RET_OK, RET_OOM);
break;
}
case '>': {
return_value_if_fail(str_append(str, ">") == RET_OK, RET_OOM);
break;
}
case '&': {
return_value_if_fail(str_append(str, "&") == RET_OK, RET_OOM);
break;
}
case '"': {
return_value_if_fail(str_append(str, """) == RET_OK, RET_OOM);
break;
}
default: {
return_value_if_fail(str_append_char(str, c) == RET_OK, RET_OOM);
break;
}
}
}
return RET_OK;
}
/*https://en.wikipedia.org/wiki/Escape_sequences_in_C*/
static char str_escape_char(char c) {
switch (c) {
case '\a': {
c = 'a';
break;
}
case '\b': {
c = 'b';
break;
}
case '\033': {
c = 'e';
break;
}
case '\f': {
c = 'f';
break;
}
case '\n': {
c = 'n';
break;
}
case '\r': {
c = 'r';
break;
}
case '\t': {
c = 't';
break;
}
case '\v': {
c = 'v';
break;
}
default: {
break;
}
}
return c;
}
static char str_unescape_char(const char* s, uint32_t* nr) {
char c = 0;
const char* start = s;
return_value_if_fail(s != NULL && nr != NULL, 0);
switch (*s++) {
case 'a': {
c = '\a';
break;
}
case 'b': {
c = '\b';
break;
}
case 'e': {
c = '\033';
break;
}
case 'f': {
c = '\f';
break;
}
case 'n': {
c = '\n';
break;
}
case 'r': {
c = '\r';
break;
}
case 't': {
c = '\t';
break;
}
case 'v': {
c = '\v';
break;
}
case '\'': {
c = '\'';
break;
}
case '\"': {
c = '\"';
break;
}
case '\\': {
c = '\\';
break;
}
case '?': {
c = '\?';
break;
}
case 'x': {
int32_t v = 0;
tk_sscanf(s, "%02x", &v);
c = v;
s += 2;
break;
}
case '\0': {
c = '\\';
break;
}
default: {
log_warn("not support char: [%c]\n", *s);
break;
}
}
*nr = s - start;
return c;
}
ret_t str_append_unescape(str_t* str, const char* s, uint32_t size) {
uint32_t i = 0;
return_value_if_fail(str != NULL && s != NULL, RET_BAD_PARAMS);
size = tk_min_int(strlen(s), size);
for (i = 0; i < size; i++) {
char c = *s++;
if (c == '\\') {
uint32_t nr = 0;
c = str_unescape_char(s, &nr);
i += nr;
s += nr;
}
str_append_char(str, c);
}
return RET_OK;
}
ret_t str_append_escape(str_t* str, const char* s, uint32_t size) {
uint32_t i = 0;
return_value_if_fail(str != NULL && s != NULL, RET_BAD_PARAMS);
size = tk_min_int(strlen(s), size);
for (i = 0; i < size; i++) {
char c = str_escape_char(s[i]);
if (c != s[i] || c == '\\' || c == '\'' || c == '\"') {
str_append_char(str, '\\');
}
str_append_char(str, c);
}
return RET_OK;
}
ret_t str_unescape(str_t* str) {
char* s = NULL;
char* d = NULL;
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
s = str->str;
d = str->str;
while ((s - str->str) < str->size) {
char c = *s++;
if (c == '\\') {
uint32_t nr = 0;
c = str_unescape_char(s, &nr);
s += nr;
}
*d++ = c;
}
*d = '\0';
str->size = d - str->str;
return RET_OK;
}
bool_t str_eq(str_t* str, const char* text) {
if ((str == NULL && text == NULL) || (str != NULL && str->str == NULL && text == NULL)) {
return TRUE;
}
if (str == NULL || text == NULL || str->str == NULL) {
return FALSE;
}
if (str->str[0] != text[0]) {
return FALSE;
}
return strcmp(str->str, text) == 0;
}
bool_t str_equal(str_t* str, str_t* other) {
if (str == other) {
return TRUE;
}
if (str == NULL || other == NULL) {
return FALSE;
}
if (str->str == other->str) {
return TRUE;
}
if (str->str == NULL || other->str == NULL) {
return FALSE;
}
return strcmp(str->str, other->str) == 0;
}
ret_t str_from_int(str_t* str, int32_t value) {
char buff[TK_NUM_MAX_LEN + 1];
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return str_set(str, tk_itoa(buff, sizeof(buff), value));
}
ret_t str_from_uint32(str_t* str, uint32_t value) {
char num[32] = {0};
tk_snprintf(num, sizeof(num) - 1, "%u", value);
return str_set(str, num);
}
ret_t str_from_float(str_t* str, double value) {
char buff[TK_NUM_MAX_LEN + 1];
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return str_set(str, tk_ftoa(buff, sizeof(buff), value));
}
ret_t str_from_value(str_t* str, const value_t* value) {
return_value_if_fail(str != NULL && value != NULL, RET_BAD_PARAMS);
if (value->type == VALUE_TYPE_STRING) {
return str_set(str, value_str(value));
} else if (value->type == VALUE_TYPE_WSTRING) {
return str_from_wstr(str, value_wstr(value));
} else if (value->type == VALUE_TYPE_FLOAT || value->type == VALUE_TYPE_FLOAT32 ||
value->type == VALUE_TYPE_DOUBLE) {
return str_from_float(str, value_float(value));
} else if (value->type == VALUE_TYPE_BOOL) {
return str_set(str, value_bool(value) ? "true" : "false");
} else {
return str_from_int(str, value_int(value));
}
}
ret_t str_from_wstr_with_len(str_t* str, const wchar_t* wstr, uint32_t len) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
str->size = 0;
if (str->str != NULL) {
str->str[0] = '\0';
}
if (wstr != NULL) {
uint32_t size = len * 6 + 1;
return_value_if_fail(str_extend(str, size + 1) == RET_OK, RET_OOM);
if (size > 0) {
tk_utf8_from_utf16_ex(wstr, len, str->str, size);
str->size = strlen(str->str);
} else {
str_set(str, "");
}
}
return RET_OK;
}
ret_t str_from_wstr(str_t* str, const wchar_t* wstr) {
return_value_if_fail(str != NULL && wstr != NULL, RET_BAD_PARAMS);
return str_from_wstr_with_len(str, wstr, wcslen(wstr));
}
ret_t str_to_int(str_t* str, int32_t* v) {
return_value_if_fail(str != NULL && v != NULL, RET_BAD_PARAMS);
*v = tk_atoi(str->str);
return RET_OK;
}
ret_t str_to_float(str_t* str, double* v) {
return_value_if_fail(str != NULL && v != NULL, RET_BAD_PARAMS);
*v = tk_atof(str->str);
return RET_OK;
}
ret_t str_reset(str_t* str) {
return_value_if_fail(str != NULL, RET_OK);
if (str->extendable) {
TKMEM_FREE(str->str);
}
str->str = NULL;
str->size = 0;
str->capacity = 0;
return RET_OK;
}
bool_t str_end_with(str_t* str, const char* text) {
size_t len = 0;
return_value_if_fail(str != NULL && str->str != NULL && text != NULL, FALSE);
len = strlen(text);
if (len > str->size) {
return FALSE;
}
return strncmp(str->str + str->size - len, text, len) == 0;
}
bool_t str_start_with(str_t* str, const char* text) {
return_value_if_fail(str != NULL && str->str != NULL && text != NULL, FALSE);
return strncmp(str->str, text, strlen(text)) == 0;
}
ret_t str_trim_left(str_t* str, const char* text) {
uint32_t i = 0;
uint32_t k = 0;
char* p = str->str;
uint32_t n = str->size;
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
if (!str->size) {
return RET_OK;
}
if (text == NULL) {
text = " ";
}
for (i = 0; i < n; i++) {
char c = p[i];
if (strchr(text, c) == NULL) {
break;
}
}
str->size = n - i;
for (k = 0; i < n; i++, k++) {
p[k] = p[i];
}
str->str[str->size] = '\0';
return RET_OK;
}
ret_t str_trim_right(str_t* str, const char* text) {
int32_t i = 0;
char* p = str->str;
uint32_t n = str->size;
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
if (!str->size) {
return RET_OK;
}
if (text == NULL) {
text = " ";
}
for (i = n - 1; i >= 0; i--) {
char c = p[i];
if (strchr(text, c) == NULL) {
break;
}
}
p[i + 1] = '\0';
str->size = i + 1;
return RET_OK;
}
ret_t str_trim(str_t* str, const char* text) {
if (!str->size) {
return RET_OK;
}
str_trim_left(str, text);
return str_trim_right(str, text);
}
static uint32_t str_count_sub_str(str_t* s, const char* str) {
char* p = s->str;
uint32_t count = 0;
uint32_t size = strlen(str);
if (size == 0) {
return 0;
}
do {
p = strstr(p, str);
if (p != NULL) {
count++;
p += size;
}
} while (p != NULL);
return count;
}
static uint32_t str_replace_impl(char* dst, char* src, const char* text, const char* new_text) {
char* d = dst;
char* s = src;
uint32_t text_len = strlen(text);
uint32_t new_text_len = strlen(new_text);
while (*s) {
if (memcmp(s, text, text_len) == 0) {
memcpy(d, new_text, new_text_len);
s += text_len;
d += new_text_len;
} else {
*d++ = *s++;
}
}
*d = '\0';
return d - dst;
}
ret_t str_replace(str_t* str, const char* text, const char* new_text) {
uint32_t count = 0;
uint32_t text_len = 0;
uint32_t new_text_len = 0;
return_value_if_fail(str != NULL && str->str != NULL, RET_BAD_PARAMS);
return_value_if_fail(text != NULL && new_text != NULL, RET_BAD_PARAMS);
return_value_if_fail(*text, RET_BAD_PARAMS);
text_len = strlen(text);
new_text_len = strlen(new_text);
count = str_count_sub_str(str, text);
if (count > 0) {
int32_t delta_len = new_text_len - text_len;
uint32_t capacity = str->size + count * delta_len + 1;
if (delta_len <= 0) {
uint32_t size = str_replace_impl(str->str, str->str, text, new_text);
str->size = size;
} else if (str->extendable) {
char* temp_str = (char*)TKMEM_ALLOC(capacity);
uint32_t size = str_replace_impl(temp_str, str->str, text, new_text);
TKMEM_FREE(str->str);
str->str = temp_str;
str->size = size;
str->capacity = capacity;
} else {
return_value_if_fail(str->extendable, RET_FAIL);
}
}
return RET_OK;
}
ret_t str_to_lower(str_t* s) {
uint32_t i = 0;
char* p = s->str;
uint32_t n = s->size;
return_value_if_fail(s != NULL && s->str != NULL, RET_BAD_PARAMS);
for (i = 0; i < n; i++) {
p[i] = tolower(p[i]);
}
return RET_OK;
}
ret_t str_to_upper(str_t* s) {
uint32_t i = 0;
char* p = s->str;
uint32_t n = s->size;
return_value_if_fail(s != NULL && s->str != NULL, RET_BAD_PARAMS);
for (i = 0; i < n; i++) {
p[i] = toupper(p[i]);
}
return RET_OK;
}
ret_t str_insert_with_len(str_t* s, uint32_t offset, const char* text, uint32_t size) {
return_value_if_fail(s != NULL && offset <= s->size && text != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(s, s->size + size + 1) == RET_OK, RET_OOM);
memmove(s->str + offset + size, s->str + offset, strlen(s->str + offset));
memcpy(s->str + offset, text, size);
s->size += size;
s->str[s->size] = '\0';
return RET_OK;
}
ret_t str_insert(str_t* s, uint32_t offset, const char* text) {
return_value_if_fail(s != NULL && offset <= s->size && text != NULL, RET_BAD_PARAMS);
return str_insert_with_len(s, offset, text, strlen(text));
}
ret_t str_remove(str_t* s, uint32_t offset, uint32_t size) {
return_value_if_fail(s != NULL && (offset + size) <= s->size && size > 0, RET_BAD_PARAMS);
memmove(s->str + offset, s->str + offset + size, strlen(s->str + offset + size));
s->size -= size;
s->str[s->size] = '\0';
return RET_OK;
}
static const char* expand_var(str_t* str, const char* p, const tk_object_t* obj) {
value_t v;
uint32_t len = 0;
char name[TK_NAME_LEN + 1];
const char* end = strchr(p, '}');
return_value_if_fail(end != NULL, p);
len = end - p;
return_value_if_fail(len <= TK_NAME_LEN, end + 1);
tk_strncpy(name, p, len);
if (tk_object_eval((tk_object_t*)obj, name, &v) != RET_OK) {
value_reset(&v);
return end + 1;
}
if (v.type == VALUE_TYPE_STRING) {
str_append(str, value_str(&v));
} else {
char num[TK_NUM_MAX_LEN + 1];
tk_snprintf(num, TK_NUM_MAX_LEN, "%d", value_int(&v));
str_append(str, num);
}
value_reset(&v);
return end + 1;
}
ret_t str_expand_vars(str_t* str, const char* src, const tk_object_t* obj) {
const char* p = src;
return_value_if_fail(str != NULL && src != NULL && obj != NULL, RET_BAD_PARAMS);
while (*p) {
char c = *p;
if (c == '$') {
if (strncmp(p, "${}", 3) == 0) {
p += 3;
} else if (p[1] && p[2]) {
p = expand_var(str, p + 2, obj);
} else {
return RET_BAD_PARAMS;
}
} else {
str_append_char(str, c);
p++;
}
}
return RET_OK;
}
ret_t str_pop(str_t* str) {
return_value_if_fail(str != NULL && str->size > 0, RET_BAD_PARAMS);
str->size--;
str->str[str->size] = '\0';
return RET_OK;
}
ret_t str_append_double(str_t* str, const char* format, double value) {
char buff[64];
const char* fmt = format != NULL ? format : "%.4lf";
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
tk_snprintf(buff, sizeof(buff), fmt, value);
return str_append(str, buff);
}
ret_t str_append_c_str(str_t* str, const char* c_str) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append_char(str, '\"') == RET_OK, RET_OOM);
if (c_str != NULL) {
str_append_escape(str, c_str, strlen(c_str));
}
return_value_if_fail(str_append_char(str, '\"') == RET_OK, RET_OOM);
return RET_OK;
}
ret_t str_append_json_str(str_t* str, const char* json_str) {
const char* p = json_str;
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append_char(str, '\"') == RET_OK, RET_OOM);
if (p != NULL) {
while (*p) {
if (*p == '\"') {
return_value_if_fail(str_append(str, "\\\"") == RET_OK, RET_OOM);
} else if (*p == '\n') {
return_value_if_fail(str_append(str, "\\n") == RET_OK, RET_OOM);
} else if (*p == '\r') {
return_value_if_fail(str_append(str, "\\r") == RET_OK, RET_OOM);
} else if (*p == '\t') {
return_value_if_fail(str_append(str, "\\t") == RET_OK, RET_OOM);
} else if (*p == '\b') {
return_value_if_fail(str_append(str, "\\b") == RET_OK, RET_OOM);
} else if (*p == '\f') {
return_value_if_fail(str_append(str, "\\f") == RET_OK, RET_OOM);
} else if (*p == '\\') {
return_value_if_fail(str_append(str, "\\\\") == RET_OK, RET_OOM);
} else {
return_value_if_fail(str_append_char(str, *p) == RET_OK, RET_OOM);
}
p++;
}
}
return_value_if_fail(str_append_char(str, '\"') == RET_OK, RET_OOM);
return RET_OK;
}
ret_t str_append_json_int_pair(str_t* str, const char* key, int32_t value) {
return_value_if_fail(str != NULL && key != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append_json_str(str, key) == RET_OK, RET_OOM);
return_value_if_fail(str_append_char(str, ':') == RET_OK, RET_OOM);
return_value_if_fail(str_append_int(str, value) == RET_OK, RET_OOM);
return RET_OK;
}
ret_t str_append_json_str_pair(str_t* str, const char* key, const char* value) {
return_value_if_fail(str != NULL && key != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append_json_str(str, key) == RET_OK, RET_OOM);
return_value_if_fail(str_append_char(str, ':') == RET_OK, RET_OOM);
return_value_if_fail(str_append_json_str(str, value) == RET_OK, RET_OOM);
return RET_OK;
}
ret_t str_append_json_double_pair(str_t* str, const char* key, double value) {
return_value_if_fail(str != NULL && key != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append_json_str(str, key) == RET_OK, RET_OOM);
return_value_if_fail(str_append_char(str, ':') == RET_OK, RET_OOM);
return_value_if_fail(str_append_double(str, NULL, value) == RET_OK, RET_OOM);
return RET_OK;
}
ret_t str_append_json_bool_pair(str_t* str, const char* key, bool_t value) {
return_value_if_fail(str != NULL && key != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_append_json_str(str, key) == RET_OK, RET_OOM);
return_value_if_fail(str_append_char(str, ':') == RET_OK, RET_OOM);
return_value_if_fail(str_append(str, value ? "true" : "false") == RET_OK, RET_OOM);
return RET_OK;
}
ret_t str_encode_hex(str_t* str, const void* data, uint32_t size, const char* format) {
char tstr[64];
uint32_t i = 0;
const uint8_t* p = data;
return_value_if_fail(str != NULL && data != NULL, RET_BAD_PARAMS);
if (format == NULL) {
format = "%02x";
}
for (i = 0; i < size; i++) {
tk_snprintf(tstr, sizeof(tstr) - 1, format, p[i]);
return_value_if_fail(str_append(str, tstr) == RET_OK, RET_OOM);
}
return RET_OK;
}
ret_t str_decode_hex(str_t* str, void* data, uint32_t size) {
char* p = NULL;
char v[3] = {0, 0, 0};
uint8_t* d = data;
uint8_t* dend = d + size;
return_value_if_fail(str != NULL && data != NULL, RET_BAD_PARAMS);
for (p = str->str; p < str->str + str->size && d < dend; p += 2) {
while (p[0] == ' ') {
p++;
}
if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
p += 2;
}
tk_strncpy(v, p, 2);
*d = tk_strtol(v, 0, 16);
d++;
}
return RET_OK;
}
ret_t str_common_prefix(str_t* str, const char* other) {
uint32_t i = 0;
return_value_if_fail(str != NULL && other != NULL, RET_BAD_PARAMS);
for (i = 0; i < str->size && other[i] != '\0'; i++) {
if (str->str[i] != other[i]) {
break;
}
}
str->str[i] = '\0';
str->size = i;
return RET_OK;
}
ret_t str_reverse(str_t* str) {
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
if (str->size > 1) {
char* start = str->str;
char* end = str->str + str->size - 1;
while (start < end) {
char c = *start;
*start = *end;
*end = c;
start++;
end--;
}
}
return RET_OK;
}
uint32_t str_count(str_t* str, const char* substr) {
return_value_if_fail(str != NULL && substr != NULL, 0);
return str_count_sub_str(str, substr);
}
ret_t str_format(str_t* str, uint32_t size, const char* format, ...) {
va_list va;
int32_t ret = 0;
return_value_if_fail(str != NULL && format != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, size + 1) == RET_OK, RET_OOM);
va_start(va, format);
ret = tk_vsnprintf(str->str, size, format, va);
va_end(va);
return_value_if_fail(ret >= 0, RET_BAD_PARAMS);
str->size = ret;
return RET_OK;
}
ret_t str_append_format(str_t* str, uint32_t size, const char* format, ...) {
va_list va;
int32_t ret = 0;
return_value_if_fail(str != NULL && format != NULL, RET_BAD_PARAMS);
return_value_if_fail(str_extend(str, str->size + size + 1) == RET_OK, RET_OOM);
va_start(va, format);
ret = tk_vsnprintf(str->str + str->size, size, format, va);
va_end(va);
return_value_if_fail(ret >= 0, RET_BAD_PARAMS);
str->size += ret;
return RET_OK;
}
ret_t str_append_json_pair(str_t* str, const char* key, const value_t* value) {
ret_t ret;
return_value_if_fail(str != NULL && key != NULL && value, RET_BAD_PARAMS);
return_value_if_fail(str_append_json_str(str, key) == RET_OK, RET_OOM);
return_value_if_fail(str_append_char(str, ':') == RET_OK, RET_OOM);
if (value->type == VALUE_TYPE_BOOL) {
return_value_if_fail(str_append(str, value_bool(value) ? "true" : "false") == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_INT8 || value->type == VALUE_TYPE_INT16 ||
value->type == VALUE_TYPE_INT32) {
return_value_if_fail(str_append_int(str, value_int32(value)) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_UINT8 || value->type == VALUE_TYPE_UINT16 ||
value->type == VALUE_TYPE_UINT32) {
return_value_if_fail(str_append_uint32(str, value_uint32(value)) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_UINT64) {
return_value_if_fail(str_append_uint64(str, value_uint64(value)) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_INT64) {
return_value_if_fail(str_append_int64(str, value_int64(value)) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_DOUBLE || value->type == VALUE_TYPE_FLOAT32 ||
value->type == VALUE_TYPE_FLOAT) {
return_value_if_fail(str_append_double(str, NULL, value_double(value)) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_STRING) {
return_value_if_fail(str_append_json_str(str, value_str(value)) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_SIZED_STRING) {
sized_str_t* ss = value_sized_str(value);
return_value_if_fail(ss, RET_BAD_PARAMS);
return_value_if_fail(str_append_json_str(str, ss->str) == RET_OK, RET_OOM);
} else if (value->type == VALUE_TYPE_BINARY) {
str_t hexstr;
binary_data_t* bd = value_binary_data(value);
return_value_if_fail(bd, RET_BAD_PARAMS);
return_value_if_fail(str_init(&hexstr, bd->size * 2 + 1) != NULL, RET_OOM);
ret = str_encode_hex(&hexstr, bd->data, bd->size, NULL);
if (ret != RET_OK) {
str_reset(&hexstr);
return ret;
}
ret = str_append_json_str(str, hexstr.str);
if (ret != RET_OK) {
str_reset(&hexstr);
return ret;
}
str_reset(&hexstr);
}
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/utils.c
|
/**
* File: utils.h
* Author: AWTK Develop Team
* Brief: utils struct and utils functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-21 Li XianJing <[email protected]> created
*
*/
#ifndef WITH_WASM
#include "tkc/thread.h"
#endif /*WITH_WASM*/
#include "tkc/fs.h"
#include "tkc/path.h"
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/wstr.h"
#include "tkc/utils.h"
#include "tkc/object.h"
#include "tkc/named_value.h"
#include "tkc/data_reader_factory.h"
#include "tkc/data_writer_factory.h"
#define IS_ADDRESS_ALIGN_4(addr) !((((size_t)(addr)) & 0x3) | 0x0)
#ifndef WITH_WASM
static uint64_t s_ui_thread_id = 0;
ret_t tk_set_ui_thread(uint64_t ui_thread_id) {
s_ui_thread_id = ui_thread_id;
return RET_OK;
}
bool_t tk_is_ui_thread(void) {
return s_ui_thread_id == tk_thread_self();
}
#endif /*WITH_WASM*/
const char* tk_skip_to_num(const char* str) {
const char* p = str;
return_value_if_fail(str != NULL, NULL);
while (*p && (*p < '0' || *p > '9')) p++;
return p;
}
int tk_str2bool(const char* str) {
if (str == NULL || str[0] == '0' || strcmp(str, "false") == 0 || strcmp(str, "no") == 0) {
return 0;
}
return 1;
}
bool_t tk_atob(const char* str) {
if (str == NULL || *str == 'f' || *str == 'F') {
return FALSE;
}
return TRUE;
}
#ifdef HAS_NO_LIBC
static long tk_strtol_internal(const char* str, const char** end, int base) {
int i = 0;
long n = 0;
char c = 0;
return_value_if_fail(str != NULL && (base == 10 || base == 8 || base == 16), 0);
if (base == 10) {
for (i = 0; str[i] && i < 10; i++) {
c = str[i];
if (c < '0' || c > '9') {
break;
}
n = n * base + c - '0';
}
} else if (base == 8) {
for (i = 0; str[i] && i < 10; i++) {
c = str[i];
if (c < '0' || c > '7') {
break;
}
n = n * base + c - '0';
}
} else if (base == 16) {
for (i = 0; str[i] && i < 10; i++) {
c = str[i];
if ((c >= '0' && c <= '9')) {
c -= '0';
} else if (c >= 'a' && c <= 'f') {
c = c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
c = c - 'A' + 10;
} else {
break;
}
n = n * base + c;
}
}
if (end != NULL) {
*end = str + i;
}
return n;
}
long tk_strtol(const char* str, const char** end, int base) {
long n = 0;
int neg = 0;
return_value_if_fail(str != NULL, 0);
while (*str == ' ' || *str == '\t') str++;
if (*str == '+' || *str == '-') {
neg = *str == '-';
str++;
}
n = tk_strtol_internal(str, end, base);
return neg ? -n : n;
}
double tk_atof(const char* str) {
int n = 0;
uint32_t zero = 0;
unsigned int f = 0;
int neg = 0;
double result = 0;
const char* p = NULL;
return_value_if_fail(str != NULL, 0);
if (str[0] == '+' || str[0] == '-') {
neg = str[0] == '-';
str++;
}
n = tk_strtol_internal(str, &p, 10);
if (p != NULL && *p == '.') {
p++;
while (*p && *p == '0') {
p++;
zero++;
}
f = tk_strtol_internal(p, NULL, 10);
}
result = f;
while (result >= 1) {
result = result / 10;
}
while (zero > 0) {
result = result / 10;
zero--;
}
result = n + result;
return neg ? -result : result;
}
static const char* tk_itoa_simple(char* str, int len, int64_t n, const char** end) {
int i = 0;
int need_len = 0;
int64_t value = n;
return_value_if_fail(str != NULL && len > 2, NULL);
if (n == 0) {
str[0] = '0';
str[1] = '\0';
if (end != NULL) {
*end = str + 1;
}
return str;
}
if (n < 0) {
n = -n;
str[0] = '-';
need_len++;
}
value = n;
while (value > 0) {
value = value / 10;
need_len++;
}
need_len++; /*for null char*/
return_value_if_fail(len > (need_len), NULL);
i = need_len - 2;
while (n > 0) {
str[i--] = (n % 10) + '0';
n = n / 10;
}
str[need_len - 1] = '\0';
if (end != NULL) {
*end = str + need_len - 1;
}
return str;
}
const char* tk_itoa(char* str, int len, int n) {
return tk_itoa_simple(str, len, n, NULL);
}
const char* tk_lltoa(char* str, int len, uint64_t n) {
return tk_itoa_simple(str, len, n, NULL);
}
#else
double tk_atof(const char* str) {
return_value_if_fail(str != NULL, 0);
return atof(str);
}
int32_t tk_strtoi(const char* str, const char** end, int base) {
long ret = tk_strtol(str, end, base);
if (ret > INT32_MAX) {
ret = INT32_MAX;
} else if (ret < INT32_MIN) {
ret = INT32_MIN;
}
return (int32_t)ret;
}
long tk_strtol(const char* str, const char** end, int base) {
return_value_if_fail(str != NULL, 0);
return strtol(str, (char**)end, base);
}
int64_t tk_strtoll(const char* str, const char** end, int base) {
return strtoll(str, (char**)end, base);
}
uint64_t tk_strtoull(const char* str, const char** end, int base) {
return strtoull(str, (char**)end, base);
}
const char* tk_itoa(char* str, int len, int n) {
return_value_if_fail(str != NULL, NULL);
tk_snprintf(str, len, "%d", n);
return str;
}
const char* tk_lltoa(char* str, int len, int64_t n) {
return_value_if_fail(str != NULL, NULL);
tk_snprintf(str, len, "%" PRId64, n);
return str;
}
#endif /*HAS_NO_LIBC*/
#define IS_HEX_NUM(s) (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
#define IS_BIN_NUM(s) (s[0] == '0' && (s[1] == 'b' || s[1] == 'B'))
int32_t tk_atoi(const char* str) {
return_value_if_fail(str != NULL, 0);
if (IS_HEX_NUM(str)) {
return tk_strtoi(str + 2, NULL, 16);
} else if (str[0] == '#') {
return tk_strtoi(str + 1, NULL, 16);
} else if (IS_BIN_NUM(str)) {
return tk_strtoi(str + 2, NULL, 2);
} else {
return tk_strtoi(str, NULL, 10);
}
}
int64_t tk_atol(const char* str) {
return_value_if_fail(str != NULL, 0);
if (IS_HEX_NUM(str)) {
return tk_strtoll(str + 2, NULL, 16);
} else if (str[0] == '#') {
return tk_strtoll(str + 1, NULL, 16);
} else if (IS_BIN_NUM(str)) {
return tk_strtoll(str + 2, NULL, 2);
} else {
return tk_strtoll(str, NULL, 10);
}
}
uint64_t tk_atoul(const char* str) {
return_value_if_fail(str != NULL, 0);
if (IS_HEX_NUM(str)) {
return tk_strtoull(str + 2, NULL, 16);
} else if (str[0] == '#') {
return tk_strtoull(str + 1, NULL, 16);
} else if (IS_BIN_NUM(str)) {
return tk_strtoull(str + 2, NULL, 2);
} else {
return tk_strtoull(str, NULL, 10);
}
}
const char* tk_ftoa(char* str, int len, double value) {
tk_snprintf(str, len, "%lf", value);
return str;
}
char* tk_strcpy(char* dst, const char* src) {
return_value_if_fail(dst != NULL && src != NULL, NULL);
if (dst != src) {
return strcpy(dst, src);
} else {
return dst;
}
}
char* tk_strncpy(char* dst, const char* src, size_t len) {
return_value_if_fail(dst != NULL && src != NULL, NULL);
if (dst != src) {
strncpy(dst, src, len);
dst[len] = '\0';
}
return dst;
}
char* tk_strncpy_s(char* dst, size_t dst_len, const char* src, size_t src_len) {
size_t len = 0;
return_value_if_fail(dst != NULL && src != NULL && dst_len > 0, NULL);
len = tk_min(dst_len - 1, src_len);
return tk_strncpy(dst, src, len);
}
char* tk_strndup(const char* str, uint32_t len) {
char* s = NULL;
return_value_if_fail(str != NULL, NULL);
s = (char*)TKMEM_ALLOC(len + 1);
if (s != NULL) {
memcpy(s, str, len);
s[len] = '\0';
}
return s;
}
void* tk_memdup(const void* data, uint32_t len) {
void* s = NULL;
return_value_if_fail(data != NULL, NULL);
s = TKMEM_ALLOC(len + 1);
if (s != NULL) {
memcpy(s, data, len);
((char*)s)[len] = '\0';
}
return s;
}
char* tk_strdup(const char* str) {
return_value_if_fail(str != NULL, NULL);
return tk_strndup(str, strlen(str));
}
wchar_t* tk_wstrdup(const wchar_t* str) {
uint32_t size = 0;
wchar_t* new_str = NULL;
return_value_if_fail(str != NULL, NULL);
size = wcslen(str) + 1;
new_str = TKMEM_ALLOC(size * sizeof(wchar_t));
return_value_if_fail(new_str != NULL, NULL);
memcpy(new_str, str, size * sizeof(wchar_t));
return new_str;
}
uint16_t* tk_memset16(uint16_t* buff, uint16_t val, uint32_t size) {
uint32_t n = 0;
uint16_t* p = buff;
uint8_t* pb = (uint8_t*)buff;
return_value_if_fail(buff != NULL, NULL);
while ((size_t)pb % 4 != 0 && size > 0) {
*p = val;
p++;
size--;
pb += 2;
}
n = size / 8; /*16bytes*/
if (n > 0) {
uint32_t* p32 = NULL;
uint32_t data = val | (val << 16);
while (n > 0) {
p32 = (uint32_t*)pb;
p32[0] = data;
p32[1] = data;
p32[2] = data;
p32[3] = data;
n--;
pb += 16;
}
}
n = size % 8;
if (n > 0) {
p = (uint16_t*)pb;
while (n > 0) {
*p = val;
p++;
n--;
}
}
return buff;
}
uint32_t* tk_memset24(uint32_t* buff, void* val, uint32_t size) {
uint32_t n = 0;
uint32_t bytes = size * 3;
uint8_t* pb = (uint8_t*)buff;
uint8_t* src = (uint8_t*)val;
while ((size_t)pb % 4 != 0 && size > 0) {
pb[0] = src[0];
pb[1] = src[1];
pb[2] = src[2];
pb += 3;
size--;
}
bytes = size * 3;
n = bytes / 12;
if (n > 0) {
uint32_t* p = NULL;
uint32_t data0 = src[0] | src[1] << 8 | src[2] << 16 | src[0] << 24;
uint32_t data1 = src[1] | src[2] << 8 | src[0] << 16 | src[1] << 24;
uint32_t data2 = src[2] | src[0] << 8 | src[1] << 16 | src[2] << 24;
while (n > 0) {
p = (uint32_t*)pb;
p[0] = data0;
p[1] = data1;
p[2] = data2;
pb += 12;
n--;
}
}
bytes = bytes % 12;
while (bytes > 0) {
pb[0] = src[0];
pb[1] = src[1];
pb[2] = src[2];
pb += 3;
bytes -= 3;
}
return buff;
}
uint32_t* tk_memset32(uint32_t* buff, uint32_t val, uint32_t size) {
uint32_t* p = buff;
return_value_if_fail(buff != NULL, NULL);
while (size-- > 0) {
*p++ = val;
}
return buff;
}
uint16_t* tk_memcpy16(uint16_t* dst, uint16_t* src, uint32_t size) {
uint16_t* d = dst;
uint16_t* s = src;
return_value_if_fail(dst != NULL && src != NULL, NULL);
while (size-- > 0) {
*d++ = *s++;
}
return dst;
}
uint32_t* tk_memcpy32(uint32_t* dst, uint32_t* src, uint32_t size) {
uint32_t* d = dst;
uint32_t* s = src;
return_value_if_fail(dst != NULL && src != NULL, NULL);
while (size-- > 0) {
*d++ = *s++;
}
return dst;
}
void* tk_pixel_copy(void* dst, const void* src, uint32_t size, uint8_t bpp) {
return_value_if_fail(dst != NULL && src != NULL, NULL);
#ifdef HAS_FAST_MEMCPY
memcpy(dst, src, size * bpp);
#else
if (bpp == 2) {
tk_memcpy16((uint16_t*)dst, (uint16_t*)src, size);
} else if (bpp == 4) {
tk_memcpy32((uint32_t*)dst, (uint32_t*)src, size);
} else {
memcpy(dst, src, size * bpp);
}
#endif /*HAS_FAST_MEMCPY*/
return dst;
}
#if defined(LINUX) || defined(APPLE) || defined(HAS_STDIO) || defined(WINDOWS)
#include <stdio.h>
#else
extern int vsscanf(const char* s, const char* format, va_list arg);
extern int vsnprintf(char* str, size_t size, const char* format, va_list ap);
#endif /*LINUX || APPLE || HAS_STDIO || WINDOWS*/
int tk_snprintf(char* str, size_t size, const char* format, ...) {
int ret = 0;
va_list va;
return_value_if_fail(str != NULL && format != NULL, 0);
va_start(va, format);
ret = tk_vsnprintf(str, size, format, va);
va_end(va);
return ret;
}
int tk_vsnprintf(char* str, size_t size, const char* format, va_list ap) {
return_value_if_fail(str != NULL && format != NULL, 0);
return vsnprintf(str, size, format, ap);
}
ret_t filename_to_name_ex(const char* filename, char* str, uint32_t size, bool_t remove_extname) {
return path_basename_ex(filename, remove_extname, str, size);
}
ret_t filename_to_name(const char* filename, char* str, uint32_t size) {
return filename_to_name_ex(filename, str, size, TRUE);
}
#define INCLUDE_XML "<?include"
#define TAG_PROPERTY "property"
#define CHAR_DOUBLE_QUOTE '\"'
#define CHAR_SINGLE_QUOTE '\''
typedef enum _xml_property_close_state_t {
XML_PROPERTY_CLOSE_STATE_CLOSE = 0x0,
XML_PROPERTY_CLOSE_STATE_OPEN_PROPERTY,
XML_PROPERTY_CLOSE_STATE_OPEN_DOUBLE_QUOTE,
XML_PROPERTY_CLOSE_STATE_OPEN_SINGLE_QUOTE,
} xml_property_close_state_t;
static xml_property_close_state_t xml_property_get_close_state(const char* start, const char* end) {
const char* tmp = start;
xml_property_close_state_t close_state = XML_PROPERTY_CLOSE_STATE_CLOSE;
while (tmp != end) {
if (*tmp == CHAR_DOUBLE_QUOTE) {
if (close_state == XML_PROPERTY_CLOSE_STATE_OPEN_DOUBLE_QUOTE) {
close_state = XML_PROPERTY_CLOSE_STATE_CLOSE;
} else if (close_state == XML_PROPERTY_CLOSE_STATE_CLOSE) {
close_state = XML_PROPERTY_CLOSE_STATE_OPEN_DOUBLE_QUOTE;
}
} else if (*tmp == CHAR_SINGLE_QUOTE) {
if (close_state == XML_PROPERTY_CLOSE_STATE_OPEN_SINGLE_QUOTE) {
close_state = XML_PROPERTY_CLOSE_STATE_CLOSE;
} else if (close_state == XML_PROPERTY_CLOSE_STATE_CLOSE) {
close_state = XML_PROPERTY_CLOSE_STATE_OPEN_SINGLE_QUOTE;
}
}
tmp++;
}
return close_state;
}
ret_t tk_str_append(char* str, uint32_t max_len, const char* s) {
uint32_t len = 0;
uint32_t org_len = 0;
return_value_if_fail(str != NULL && s != NULL, RET_BAD_PARAMS);
len = strlen(s);
org_len = strlen(str);
return_value_if_fail(max_len > (len + org_len), RET_FAIL);
memcpy(str + org_len, s, len);
str[org_len + len] = '\0';
return RET_OK;
}
int32_t tk_strcmp(const char* a, const char* b) {
if (a == b) {
return 0;
}
if (a == NULL) {
return -1;
}
if (b == NULL) {
return 1;
}
return strcmp(a, b);
}
int32_t tk_stricmp(const char* a, const char* b) {
if (a == b) {
return 0;
}
if (a == NULL) {
return -1;
}
if (b == NULL) {
return 1;
}
return strcasecmp(a, b);
}
int32_t tk_wstrcmp(const wchar_t* a, const wchar_t* b) {
if (a == b) {
return 0;
}
if (a == NULL) {
return -1;
}
if (b == NULL) {
return 1;
}
return wcscmp(a, b);
}
int32_t tk_wstricmp(const wchar_t* a, const wchar_t* b) {
if (a == b) {
return 0;
}
if (a == NULL) {
return -1;
}
if (b == NULL) {
return 1;
}
return wcs_case_cmp(a, b);
}
char* tk_str_copy(char* dst, const char* src) {
if (src != NULL) {
uint32_t size = strlen(src) + 1;
if (dst != NULL) {
char* str = TKMEM_REALLOCT(char, dst, size);
return_value_if_fail(str != NULL, dst);
memcpy(str, src, size);
dst = str;
} else {
char* str = (char*)TKMEM_ALLOC(size);
return_value_if_fail(str != NULL, dst);
memcpy(str, src, size);
dst = str;
}
} else {
if (dst != NULL) {
*dst = '\0';
}
}
return dst;
}
int tk_watoi_n(const wchar_t* str, uint32_t len) {
char num[TK_NUM_MAX_LEN + 1] = {0};
return_value_if_fail(str != NULL, 0);
memset(num, 0x00, sizeof(num));
tk_utf8_from_utf16_ex(str, len, num, TK_NUM_MAX_LEN);
return tk_atoi(num);
}
int tk_watoi(const wchar_t* str) {
return_value_if_fail(str != NULL, 0);
return tk_watoi_n(str, wcslen(str));
}
bool_t tk_watob(const wchar_t* str) {
if (str == NULL || *str == 'f' || *str == 'F') {
return FALSE;
}
return TRUE;
}
double tk_watof(const wchar_t* str) {
char num[TK_NUM_MAX_LEN + 1] = {0};
return_value_if_fail(str != NULL, 0);
tk_utf8_from_utf16(str, num, TK_NUM_MAX_LEN);
return tk_atof(num);
}
ret_t default_destroy(void* data) {
TKMEM_FREE(data);
return RET_OK;
}
ret_t dummy_destroy(void* data) {
return RET_OK;
}
int pointer_compare(const void* a, const void* b) {
return ((const char*)a - (const char*)b);
}
int compare_always_equal(const void* a, const void* b) {
return 0;
}
ret_t tk_replace_locale(const char* name, char out[TK_NAME_LEN + 1], const char* locale) {
char* d = NULL;
char* p = NULL;
int32_t len = 0;
const char* s = NULL;
return_value_if_fail(strlen(name) < TK_NAME_LEN, RET_BAD_PARAMS);
return_value_if_fail(strlen(locale) <= strlen(TK_LOCALE_MAGIC), RET_BAD_PARAMS);
return_value_if_fail(name != NULL && out != NULL && locale != NULL, RET_BAD_PARAMS);
d = out;
s = name;
p = strstr(name, TK_LOCALE_MAGIC);
return_value_if_fail(p != NULL, RET_BAD_PARAMS);
len = p - s;
memcpy(d, s, len);
d += len;
len = strlen(locale);
memcpy(d, locale, len);
d += len;
strcpy(d, p + strlen(TK_LOCALE_MAGIC));
return RET_OK;
}
bool_t tk_is_valid_name(const char* name) {
const char* p = name;
while (*p) {
if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || (*p >= '0' && *p <= '9') ||
*p == '_') {
p++;
} else {
return FALSE;
}
}
return TRUE;
}
bool_t tk_str_start_with(const char* str, const char* prefix) {
return_value_if_fail(str != NULL && prefix != NULL, FALSE);
return strncmp(str, prefix, strlen(prefix)) == 0;
}
bool_t tk_str_end_with(const char* str, const char* appendix) {
uint32_t len_str = 0;
uint32_t len_appendix = 0;
return_value_if_fail(str != NULL && appendix != NULL, FALSE);
len_str = strlen(str);
len_appendix = strlen(appendix);
if (len_str < len_appendix) {
return FALSE;
} else {
return strncmp(str + len_str - len_appendix, appendix, len_appendix) == 0;
}
}
bool_t tk_str_case_start_with(const char* str, const char* prefix) {
return_value_if_fail(str != NULL && prefix != NULL, FALSE);
return strncasecmp(str, prefix, strlen(prefix)) == 0;
}
bool_t tk_str_case_end_with(const char* str, const char* appendix) {
uint32_t len_str = 0;
uint32_t len_appendix = 0;
return_value_if_fail(str != NULL && appendix != NULL, FALSE);
len_str = strlen(str);
len_appendix = strlen(appendix);
if (len_str < len_appendix) {
return FALSE;
} else {
return strncasecmp(str + len_str - len_appendix, appendix, len_appendix) == 0;
}
}
const char* tk_under_score_to_camel(const char* name, char* out, uint32_t max_out_size) {
uint32_t i = 0;
const char* s = name;
return_value_if_fail(name != NULL && out != NULL && max_out_size > 0, NULL);
while (*s && i < max_out_size) {
if (*s == '_') {
s++;
if (*s != '\0') {
out[i++] = toupper(*s);
} else {
break;
}
} else {
out[i++] = *s;
}
s++;
}
out[i] = '\0';
return out;
}
int32_t tk_pointer_to_int(const void* p) {
return (int32_t)(intptr_t)p;
}
void* tk_pointer_from_int(int32_t v) {
return (void*)(intptr_t)v;
}
uint64_t tk_pointer_to_long(const void* p) {
return (uint64_t)(intptr_t)p;
}
void* tk_pointer_from_long(uint64_t v) {
return (void*)(intptr_t)v;
}
char* tk_str_toupper(char* str) {
char* p = str;
return_value_if_fail(str != NULL, NULL);
while (*p) {
*p = toupper(*p);
p++;
}
return str;
}
char* tk_str_totitle(char* str) {
char* p = str;
char* prev = str;
return_value_if_fail(str != NULL, NULL);
while (*p) {
if (tk_isalpha(*p)) {
if (p == str || (!tk_isalpha(*prev) && !tk_isdigit(*prev))) {
*p = toupper(*p);
}
}
prev = p;
p++;
}
return str;
}
char* tk_str_tolower(char* str) {
char* p = str;
return_value_if_fail(str != NULL, NULL);
while (*p) {
*p = tolower(*p);
p++;
}
return str;
}
const char* tk_normalize_key_name(const char* name, char fixed_name[TK_NAME_LEN + 1]) {
uint32_t len = 0;
return_value_if_fail(name != NULL && fixed_name != NULL, NULL);
len = strlen(name);
tk_strncpy(fixed_name, name, TK_NAME_LEN);
if (len > 1) {
tk_str_toupper(fixed_name);
}
return fixed_name;
}
uint32_t tk_strlen(const char* str) {
if (str == NULL || *str == '\0') {
return 0;
}
return strlen(str);
}
wchar_t* tk_wstr_dup_utf8(const char* str) {
int32_t len = 0;
int32_t size = 0;
wchar_t* wstr = NULL;
return_value_if_fail(str != NULL, NULL);
len = strlen(str) + 1;
size = len * sizeof(wchar_t);
wstr = TKMEM_ALLOC(size);
return_value_if_fail(wstr != NULL, NULL);
memset(wstr, 0x00, size);
tk_utf8_to_utf16(str, wstr, len);
return wstr;
}
uint32_t tk_wstr_count_c(const wchar_t* str, wchar_t c) {
uint32_t nr = 0;
const wchar_t* p = str;
return_value_if_fail(p != NULL, nr);
while (*p) {
if (*p == c) {
nr++;
}
p++;
}
return nr;
}
uint32_t tk_count_char(const char* str, char c) {
uint32_t nr = 0;
const char* p = str;
return_value_if_fail(p != NULL, nr);
while (*p) {
if (*p == c) {
nr++;
}
p++;
}
return nr;
}
ret_t tk_wstr_select_word(const wchar_t* str, uint32_t len, uint32_t index, int32_t* left,
int32_t* right) {
int32_t i = 0;
const wchar_t* no_start_symbols = L",.?!)>:;，。？！》）：；";
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(index <= len, RET_BAD_PARAMS);
return_value_if_fail(left != NULL && right != NULL, RET_BAD_PARAMS);
i = (int32_t)index;
while (str != NULL && i > 0) {
--i;
if (i >= 0) {
if (wcs_chr(no_start_symbols, str[i]) != NULL) {
break;
} else if (str[i] == '\r' || str[i] == '\n') {
break;
} else if (tk_isspace(str[i])) {
break;
} else if (!tk_isspace(str[i + 1]) && wcs_chr(no_start_symbols, str[i + 1]) == NULL &&
((tk_isalpha(str[i]) && !tk_isalpha(str[i + 1])) ||
(!tk_isalpha(str[i]) && tk_isalpha(str[i + 1])))) {
break;
} else if ((tk_isdigit(str[i]) && !tk_isdigit(str[i + 1])) ||
(!tk_isdigit(str[i]) && tk_isdigit(str[i + 1]))) {
break;
}
}
}
if (i <= 0) {
*left = 0;
} else {
*left = i + 1;
}
i = (int32_t)index;
while (str != NULL && i >= 0 && i < len) {
++i;
if (i >= 0 && i <= len) {
if (wcs_chr(no_start_symbols, str[i - 1]) != NULL) {
*right = i - 1;
break;
} else if (wcs_chr(no_start_symbols, str[i]) != NULL) {
*right = i;
break;
} else if (str[i - 1] == '\r' || str[i] == '\n') {
*right = i;
break;
} else if (tk_isspace(str[i])) {
*right = i;
break;
} else if (tk_isspace(str[i - 1])) {
*right = i - 1;
break;
} else if ((tk_isalpha(str[i]) && !tk_isalpha(str[i - 1])) ||
(!tk_isalpha(str[i]) && tk_isalpha(str[i - 1]))) {
*right = i;
break;
} else if ((tk_isdigit(str[i]) && !tk_isdigit(str[i - 1])) ||
(!tk_isdigit(str[i]) && tk_isdigit(str[i - 1]))) {
*right = i;
break;
}
}
}
if (i >= len) {
*right = len > 0 ? len : 0;
}
return RET_OK;
}
ret_t image_region_parse(uint32_t img_w, uint32_t img_h, const char* region, rect_t* r) {
return_value_if_fail(r != NULL && region != NULL, RET_BAD_PARAMS);
if (*region == '#') {
region++;
}
if (strncmp(region, "xywh(", 5) == 0) {
int x = 0;
int y = 0;
int w = 0;
int h = 0;
ENSURE(tk_sscanf(region, "xywh(%d,%d,%d,%d)", &x, &y, &w, &h) == 4);
*r = rect_init(x, y, w, h);
return RET_OK;
} else if (strncmp(region, "grid(", 5) == 0) {
int rows = 0;
int cols = 0;
int row = 0;
int col = 0;
int tile_w = 0;
int tile_h = 0;
ENSURE(tk_sscanf(region, "grid(%d,%d,%d,%d)", &rows, &cols, &row, &col) == 4);
return_value_if_fail(rows > 0 && cols > 0 && row >= 0 && col >= 0, RET_FAIL);
return_value_if_fail(rows > row && cols > col, RET_FAIL);
tile_w = img_w / cols;
tile_h = img_h / rows;
*r = rect_init(col * tile_w, row * tile_h, tile_w, tile_h);
return RET_OK;
}
return RET_FAIL;
}
typedef struct _to_json_ctx_t {
tk_object_t* obj;
str_t* str;
uint32_t index;
} to_json_ctx_t;
static ret_t escape_json_str(str_t* str, const char* p) {
str_append_char(str, '\"');
if (p != NULL) {
while (*p) {
if (*p == '\"' || *p == '\\') {
str_append_char(str, '\\');
}
str_append_char(str, *p);
p++;
}
}
str_append_char(str, '\"');
return RET_OK;
}
static ret_t to_json_on_prop(void* ctx, const void* data) {
named_value_t* nv = (named_value_t*)data;
to_json_ctx_t* info = (to_json_ctx_t*)ctx;
if (info->index > 0) {
str_append_char(info->str, ',');
}
if (!tk_object_is_collection(info->obj)) {
str_append_more(info->str, "\"", nv->name, "\":", NULL);
}
switch (nv->value.type) {
case VALUE_TYPE_OBJECT: {
str_t str;
str_init(&str, 100);
object_to_json(value_object(&(nv->value)), &str);
str_append(info->str, str.str);
str_reset(&str);
break;
}
case VALUE_TYPE_STRING: {
escape_json_str(info->str, value_str(&(nv->value)));
break;
}
case VALUE_TYPE_WSTRING: {
str_t str;
str_init(&str, 100);
str_from_wstr(&str, value_wstr(&(nv->value)));
escape_json_str(info->str, str.str);
str_reset(&str);
break;
}
default: {
char buff[32];
str_append(info->str, value_str_ex(&(nv->value), buff, sizeof(buff) - 1));
break;
}
}
info->index++;
return RET_OK;
}
ret_t object_to_json(tk_object_t* obj, str_t* str) {
to_json_ctx_t ctx = {obj, str, 0};
return_value_if_fail(obj != NULL && str != NULL, RET_BAD_PARAMS);
if (tk_object_is_collection(obj)) {
str_set(str, "[");
tk_object_foreach_prop(obj, to_json_on_prop, &ctx);
str_append_char(str, ']');
} else {
str_set(str, "{");
tk_object_foreach_prop(obj, to_json_on_prop, &ctx);
str_append_char(str, '}');
}
return RET_OK;
}
#ifdef WITH_DATA_READER_WRITER
ret_t data_url_copy(const char* dst_url, const char* src_url) {
ret_t ret = RET_OK;
return_value_if_fail(dst_url != NULL && src_url != NULL, RET_BAD_PARAMS);
data_reader_t* reader = data_reader_factory_create_reader(data_reader_factory(), src_url);
if (reader != NULL) {
uint32_t size = data_reader_get_size(reader);
if (size > 0) {
data_writer_t* writer = data_writer_factory_create_writer(data_writer_factory(), dst_url);
if (writer != NULL) {
void* buff = TKMEM_CALLOC(1, size + 1);
if (buff != NULL) {
int32_t rsize = data_reader_read(reader, 0, buff, size);
assert(rsize == size);
rsize = data_writer_write(writer, 0, buff, rsize);
assert(rsize == size);
TKMEM_FREE(buff);
log_debug("copy: %s=>%s\n", src_url, dst_url);
} else {
ret = RET_FAIL;
}
data_writer_destroy(writer);
} else {
ret = RET_FAIL;
log_debug("open dst(%s) failed\n", dst_url);
}
} else {
log_debug("open src(%s) failed\n", src_url);
}
data_reader_destroy(reader);
}
return ret;
}
#endif /*WITH_DATA_READER_WRITER*/
static void tk_quick_sort_impl(void** array, size_t left, size_t right, tk_compare_t cmp) {
size_t save_left = left;
size_t save_right = right;
void* x = array[left];
while (left < right) {
while (cmp(array[right], x) >= 0 && left < right) right--;
if (left != right) {
array[left] = array[right];
left++;
}
while (cmp(array[left], x) <= 0 && left < right) left++;
if (left != right) {
array[right] = array[left];
right--;
}
}
array[left] = x;
if (save_left < left) {
tk_quick_sort_impl(array, save_left, left - 1, cmp);
}
if (save_right > left) {
tk_quick_sort_impl(array, left + 1, save_right, cmp);
}
return;
}
ret_t tk_qsort(void** array, size_t nr, tk_compare_t cmp) {
ret_t ret = RET_OK;
return_value_if_fail(array != NULL && cmp != NULL, RET_BAD_PARAMS);
if (nr > 1) {
tk_quick_sort_impl(array, 0, nr - 1, cmp);
}
return ret;
}
const char* tk_strrstr(const char* str, const char* substr) {
char c = 0;
uint32_t len = 0;
const char* p = NULL;
const char* end = NULL;
return_value_if_fail(str != NULL && substr != NULL, NULL);
c = *substr;
len = strlen(substr);
end = str + strlen(str) - 1;
for (p = end; p >= str; p--) {
if (*p == c) {
if (strncmp(p, substr, len) == 0) {
return p;
}
}
}
return NULL;
}
bool_t tk_int_is_in_array(int32_t v, const int32_t* array, uint32_t array_size) {
uint32_t i = 0;
return_value_if_fail(array != NULL && array_size > 0, FALSE);
for (i = 0; i < array_size; i++) {
if (v == array[i]) {
return TRUE;
}
}
return FALSE;
}
bool_t tk_str_is_in_array(const char* str, const char** str_array, uint32_t array_size) {
uint32_t i = 0;
return_value_if_fail(str != NULL && str_array != NULL && array_size > 0, FALSE);
for (i = 0; i < array_size; i++) {
if (tk_str_eq(str, str_array[i])) {
return TRUE;
}
}
return FALSE;
}
void* tk_memcpy_by_align_4(void* dst_align_4, const void* src_align_4, uint32_t len) {
#define MEMCPY_TINY_MAX_LENGTH 64
if (dst_align_4 != NULL && src_align_4 != NULL && len > 0) {
if (len < MEMCPY_TINY_MAX_LENGTH) {
register unsigned char* dd = (unsigned char*)dst_align_4 + len;
register const unsigned char* ss = (const unsigned char*)src_align_4 + len;
assert(IS_ADDRESS_ALIGN_4(dst_align_4));
assert(IS_ADDRESS_ALIGN_4(src_align_4));
switch (len) {
case 64:
*((int*)(dd - 64)) = *((int*)(ss - 64));
case 60:
*((int*)(dd - 60)) = *((int*)(ss - 60));
case 56:
*((int*)(dd - 56)) = *((int*)(ss - 56));
case 52:
*((int*)(dd - 52)) = *((int*)(ss - 52));
case 48:
*((int*)(dd - 48)) = *((int*)(ss - 48));
case 44:
*((int*)(dd - 44)) = *((int*)(ss - 44));
case 40:
*((int*)(dd - 40)) = *((int*)(ss - 40));
case 36:
*((int*)(dd - 36)) = *((int*)(ss - 36));
case 32:
*((int*)(dd - 32)) = *((int*)(ss - 32));
case 28:
*((int*)(dd - 28)) = *((int*)(ss - 28));
case 24:
*((int*)(dd - 24)) = *((int*)(ss - 24));
case 20:
*((int*)(dd - 20)) = *((int*)(ss - 20));
case 16:
*((int*)(dd - 16)) = *((int*)(ss - 16));
case 12:
*((int*)(dd - 12)) = *((int*)(ss - 12));
case 8:
*((int*)(dd - 8)) = *((int*)(ss - 8));
case 4:
*((int*)(dd - 4)) = *((int*)(ss - 4));
break;
case 63:
*((int*)(dd - 63)) = *((int*)(ss - 63));
case 59:
*((int*)(dd - 59)) = *((int*)(ss - 59));
case 55:
*((int*)(dd - 55)) = *((int*)(ss - 55));
case 51:
*((int*)(dd - 51)) = *((int*)(ss - 51));
case 47:
*((int*)(dd - 47)) = *((int*)(ss - 47));
case 43:
*((int*)(dd - 43)) = *((int*)(ss - 43));
case 39:
*((int*)(dd - 39)) = *((int*)(ss - 39));
case 35:
*((int*)(dd - 35)) = *((int*)(ss - 35));
case 31:
*((int*)(dd - 31)) = *((int*)(ss - 31));
case 27:
*((int*)(dd - 27)) = *((int*)(ss - 27));
case 23:
*((int*)(dd - 23)) = *((int*)(ss - 23));
case 19:
*((int*)(dd - 19)) = *((int*)(ss - 19));
case 15:
*((int*)(dd - 15)) = *((int*)(ss - 15));
case 11:
*((int*)(dd - 11)) = *((int*)(ss - 11));
case 7:
*((int*)(dd - 7)) = *((int*)(ss - 7));
case 3:
*((short*)(dd - 3)) = *((short*)(ss - 3));
dd[-1] = ss[-1];
break;
case 62:
*((int*)(dd - 62)) = *((int*)(ss - 62));
case 58:
*((int*)(dd - 58)) = *((int*)(ss - 58));
case 54:
*((int*)(dd - 54)) = *((int*)(ss - 54));
case 50:
*((int*)(dd - 50)) = *((int*)(ss - 50));
case 46:
*((int*)(dd - 46)) = *((int*)(ss - 46));
case 42:
*((int*)(dd - 42)) = *((int*)(ss - 42));
case 38:
*((int*)(dd - 38)) = *((int*)(ss - 38));
case 34:
*((int*)(dd - 34)) = *((int*)(ss - 34));
case 30:
*((int*)(dd - 30)) = *((int*)(ss - 30));
case 26:
*((int*)(dd - 26)) = *((int*)(ss - 26));
case 22:
*((int*)(dd - 22)) = *((int*)(ss - 22));
case 18:
*((int*)(dd - 18)) = *((int*)(ss - 18));
case 14:
*((int*)(dd - 14)) = *((int*)(ss - 14));
case 10:
*((int*)(dd - 10)) = *((int*)(ss - 10));
case 6:
*((int*)(dd - 6)) = *((int*)(ss - 6));
case 2:
*((short*)(dd - 2)) = *((short*)(ss - 2));
break;
case 61:
*((int*)(dd - 61)) = *((int*)(ss - 61));
case 57:
*((int*)(dd - 57)) = *((int*)(ss - 57));
case 53:
*((int*)(dd - 53)) = *((int*)(ss - 53));
case 49:
*((int*)(dd - 49)) = *((int*)(ss - 49));
case 45:
*((int*)(dd - 45)) = *((int*)(ss - 45));
case 41:
*((int*)(dd - 41)) = *((int*)(ss - 41));
case 37:
*((int*)(dd - 37)) = *((int*)(ss - 37));
case 33:
*((int*)(dd - 33)) = *((int*)(ss - 33));
case 29:
*((int*)(dd - 29)) = *((int*)(ss - 29));
case 25:
*((int*)(dd - 25)) = *((int*)(ss - 25));
case 21:
*((int*)(dd - 21)) = *((int*)(ss - 21));
case 17:
*((int*)(dd - 17)) = *((int*)(ss - 17));
case 13:
*((int*)(dd - 13)) = *((int*)(ss - 13));
case 9:
*((int*)(dd - 9)) = *((int*)(ss - 9));
case 5:
*((int*)(dd - 5)) = *((int*)(ss - 5));
case 1:
dd[-1] = ss[-1];
break;
case 0:
default:
break;
}
return dd;
}
return memcpy(dst_align_4, src_align_4, len);
} else {
return dst_align_4;
}
}
void* tk_memcpy(void* dst, const void* src, uint32_t len) {
size_t offset_src_address = ((size_t)src) & 0x3;
size_t offset_dst_address = ((size_t)dst) & 0x3;
return_value_if_fail(dst != NULL && src != NULL, NULL);
if (offset_src_address == offset_dst_address) {
uint32_t i = 0;
uint8_t* d = dst;
uint8_t* s = (uint8_t*)src;
int32_t curr_len = len;
uint32_t offset = 0x4 - offset_src_address;
if (offset_src_address != 0) {
for (i = 0; i < offset && i < len; i++) {
d[i] = s[i];
}
d += offset;
s += offset;
curr_len -= offset;
}
if (curr_len > 0) {
return tk_memcpy_by_align_4((void*)d, (const void*)s, curr_len);
} else {
return dst;
}
} else {
return memcpy(dst, src, len);
}
}
bool_t tk_wild_card_match(const char* pattern, const char* str) {
const char* p_str = str;
const char* p_pattern = pattern;
return_value_if_fail(pattern != NULL && str != NULL, FALSE);
while (*p_pattern && *p_str) {
char c = *p_pattern;
if (c == '*') {
c = p_pattern[1];
if (c == '\0') {
break;
}
while (*p_str) {
if (c == *p_str) {
break;
} else {
p_str++;
}
}
} else if (c == '?') {
p_str++;
} else {
if (c != *p_str) {
return FALSE;
}
p_str++;
}
p_pattern++;
}
return *p_pattern == '*' || *p_str == *p_pattern;
}
float_t tk_eval_ratio_or_px(const char* expr, int32_t value) {
const char* p = NULL;
return_value_if_fail(expr != NULL, 0);
p = strrchr(expr, 'p');
if (p == NULL) {
p = strrchr(expr, 'P');
}
if (p == NULL) {
float_t ratio = tk_atof(expr);
if (ratio > 1 && strchr(expr, '%') != NULL) {
/*ex: 50% */
return (value * ratio) / 100.0f;
} else {
/*ex: 0.5 */
/*ex: 0.5% (兼容以前的处理)*/
return value * ratio;
}
} else {
/*ex: 100px */
return tk_atoi(expr);
}
}
char* tk_replace_char(char* str, char from, char to) {
char* p = str;
return_value_if_fail(str != NULL, NULL);
while (*p) {
if (*p == from) {
*p = to;
}
p++;
}
return str;
}
uint32_t tk_strnlen(const char* str, uint32_t maxlen) {
const char* s;
return_value_if_fail(str != NULL, 0);
for (s = str; maxlen-- && *s != '\0'; ++s);
return s - str;
}
static ret_t xml_file_expand_subfilename_get(const char** p, const char* filename,
char subfilename[MAX_PATH + 1]) {
str_t s;
const char* sp = *p;
ret_t ret = RET_FAIL;
return_value_if_fail(sp != NULL && filename != NULL && subfilename != NULL, RET_BAD_PARAMS);
str_init(&s, 1024);
/*<include filename="subfilename">*/
while (*sp != '\"' && *sp != '\0') {
sp++;
}
goto_error_if_fail(*sp == '\"');
sp++;
while (*sp != '\"' && *sp != '\0') {
str_append_char(&s, *sp++);
}
goto_error_if_fail(*sp == '\"');
while (*sp != '>' && *sp != '\0') {
sp++;
}
goto_error_if_fail(*sp == '>');
sp++;
path_replace_basename(subfilename, MAX_PATH, filename, s.str);
*p = sp;
ret = RET_OK;
error:
str_reset(&s);
return ret;
}
ret_t xml_file_expand(const char* filename, str_t* s, const char* data) {
str_t ss;
char subfilename[MAX_PATH + 1];
const char* start = data;
const char* p = strstr(start, INCLUDE_XML);
str_init(&ss, 1024);
while (p != NULL) {
/* 过滤在属性中的 INCLUDE_XML(目前只过滤在 \' 或 \" 作用域下的文件扩展, 对于property属性中的扩展不再做限制) */
xml_property_close_state_t close_state = xml_property_get_close_state(start, p);
if (close_state == XML_PROPERTY_CLOSE_STATE_CLOSE) {
str_set(&ss, "");
str_append_with_len(s, start, p - start);
return_value_if_fail(xml_file_expand_subfilename_get(&p, filename, subfilename) == RET_OK,
RET_FAIL);
xml_file_expand_read(subfilename, &ss);
str_append(s, ss.str);
} else {
int size = 0;
char* str_end = NULL;
char* include_string_end = strstr(p, "?>");
ENSURE(include_string_end);
if (close_state == XML_PROPERTY_CLOSE_STATE_OPEN_PROPERTY) {
str_end = TAG_PROPERTY;
size = tk_strlen(TAG_PROPERTY);
} else if (close_state == XML_PROPERTY_CLOSE_STATE_OPEN_SINGLE_QUOTE) {
size = 1;
str_end = "\'";
} else if (close_state == XML_PROPERTY_CLOSE_STATE_OPEN_DOUBLE_QUOTE) {
size = 1;
str_end = "\"";
}
if (str_end == NULL) {
log_error("do not find close property string !");
} else {
p = strstr(include_string_end, str_end) + size;
str_append_with_len(s, start, p - start);
}
}
start = p;
p = strstr(start, INCLUDE_XML);
}
str_append(s, start);
str_reset(&ss);
return RET_OK;
}
ret_t xml_file_expand_read(const char* filename, str_t* s) {
uint32_t size = 0;
char* buff = NULL;
return_value_if_fail(filename != NULL && s != NULL, RET_BAD_PARAMS);
str_set(s, "");
buff = (char*)file_read(filename, &size);
return_value_if_fail(buff != NULL, RET_FAIL);
if (strstr(buff, INCLUDE_XML) != NULL) {
xml_file_expand(filename, s, buff);
} else {
str_set_with_len(s, (const char*)buff, size);
}
TKMEM_FREE(buff);
return RET_OK;
}
ret_t xml_file_expand_subfilenames_get(const char* filename, char*** subfilenames, uint32_t* size) {
ret_t ret = RET_FAIL;
uint32_t i = 0, buff_len = 0;
char *buff = NULL, *start = NULL, *p = NULL;
char subfilename[MAX_PATH + 1] = {0}, **tmp_subfilenames = NULL;
return_value_if_fail(filename != NULL && subfilenames != NULL && size != NULL, RET_BAD_PARAMS);
buff = file_read(filename, &buff_len);
return_value_if_fail(buff != NULL, RET_FAIL);
*size = 0;
start = buff;
p = strstr(start, INCLUDE_XML);
while (p != NULL) {
xml_property_close_state_t close_state = xml_property_get_close_state(start, p);
if (close_state == XML_PROPERTY_CLOSE_STATE_CLOSE) {
ret = xml_file_expand_subfilename_get((const char**)&p, filename, subfilename);
goto_error_if_fail(ret == RET_OK);
tmp_subfilenames = TKMEM_REALLOCT(char*, *subfilenames, (++(*size)));
goto_error_if_fail(tmp_subfilenames != NULL);
tmp_subfilenames[*size - 1] = tk_strdup(subfilename);
*subfilenames = tmp_subfilenames;
}
start = p;
p = strstr(start, INCLUDE_XML);
}
ret = RET_OK;
error:
if (ret != RET_OK && *size > 0) {
for (i = 0; i < *size; i++) {
TKMEM_FREE(*subfilenames[i]);
}
*size = 0;
TKMEM_FREE(*subfilenames);
}
TKMEM_FREE(buff);
return ret;
}
char* file_read_as_unix_text(const char* filename, uint32_t* size) {
str_t str;
uint32_t s = 0;
char* data = (char*)file_read(filename, &s);
return_value_if_fail(data != NULL, NULL);
str_attach_with_size(&str, data, s, s + 1);
str_replace(&str, "\r\n", "\n");
str_replace(&str, "\r", "\n");
*size = str.size;
str_reset(&str);
return data;
}
static const char* s_ret_names[RET_MAX_NR] = {[RET_OK] = "RET_OK",
[RET_OOM] = "RET_OOM",
[RET_FAIL] = "RET_FAIL",
[RET_NOT_IMPL] = "RET_NOT_IMPL",
[RET_QUIT] = "RET_QUIT",
[RET_FOUND] = "RET_FOUND",
[RET_BUSY] = "RET_BUSY",
[RET_REMOVE] = "RET_REMOVE",
[RET_REPEAT] = "RET_REPEAT",
[RET_NOT_FOUND] = "RET_NOT_FOUND",
[RET_DONE] = "RET_DONE",
[RET_STOP] = "RET_STOP",
[RET_SKIP] = "RET_SKIP",
[RET_CONTINUE] = "RET_CONTINUE",
[RET_OBJECT_CHANGED] = "RET_OBJECT_CHANGED",
[RET_ITEMS_CHANGED] = "RET_ITEMS_CHANGED",
[RET_BAD_PARAMS] = "RET_BAD_PARAMS",
[RET_TIMEOUT] = "RET_TIMEOUT",
[RET_CRC] = "RET_CRC",
[RET_IO] = "RET_IO",
[RET_EOS] = "RET_EOS",
[RET_NOT_MODIFIED] = "RET_NOT_MODIFIED",
[RET_NO_PERMISSION] = "RET_NO_PERMISSION",
[RET_INVALID_ADDR] = "RET_INVALID_ADDR",
[RET_EXCEED_RANGE] = "RET_EXCEED_RANGE"};
ret_t ret_code_from_name(const char* name) {
uint32_t i = 0;
uint32_t n = ARRAY_SIZE(s_ret_names);
for (i = 0; i < n; i++) {
if (tk_str_ieq(name, s_ret_names[i])) {
return (ret_t)i;
}
}
return RET_MAX_NR;
}
const char* ret_code_to_name(ret_t ret) {
if (ret < RET_MAX_NR) {
return s_ret_names[ret];
} else {
return "";
}
}
ret_t bits_stream_get(const uint8_t* buff, uint32_t size, uint32_t index, bool_t* value) {
uint8_t v = 0;
uint32_t offset = index % 8;
uint32_t max_index = size * 8;
return_value_if_fail(buff != NULL, RET_BAD_PARAMS);
return_value_if_fail(value != NULL, RET_BAD_PARAMS);
if (index >= max_index) {
log_debug("bits_stream_get failed: %u >= %u\n", index, max_index);
return RET_BAD_PARAMS;
}
return_value_if_fail(index < max_index, RET_BAD_PARAMS);
v = buff[index >> 3];
*value = TK_TEST_BIT(v, offset);
return RET_OK;
}
ret_t bits_stream_set(uint8_t* buff, uint32_t size, uint32_t index, bool_t value) {
uint8_t v = 0;
uint32_t offset = index % 8;
uint32_t max_index = size * 8;
return_value_if_fail(buff != NULL, RET_BAD_PARAMS);
if (index >= max_index) {
log_debug("bits_stream_get failed: %u >= %u\n", index, max_index);
return RET_BAD_PARAMS;
}
return_value_if_fail(index < max_index, RET_BAD_PARAMS);
v = buff[index >> 3];
if (value) {
TK_SET_BIT(v, offset);
} else {
TK_CLEAR_BIT(v, offset);
}
buff[index >> 3] = v;
return RET_OK;
}
char* tk_utf8_dup_wstr(const wchar_t* str) {
str_t s;
return_value_if_fail(str != NULL, NULL);
str_init(&s, wcslen(str) * 4 + 1);
str_from_wstr(&s, str);
return s.str;
}
char** tk_to_utf8_argv(int argc, wchar_t** argv) {
uint32_t i = 0;
char** argv_utf8 = NULL;
argv_utf8 = TKMEM_ALLOC(sizeof(char*) * argc);
return_value_if_fail(argv_utf8 != NULL, NULL);
for (i = 0; i < argc; i++) {
argv_utf8[i] = tk_utf8_dup_wstr(argv[i]);
}
return argv_utf8;
}
ret_t tk_free_utf8_argv(int argc, char** argv) {
uint32_t i = 0;
return_value_if_fail(argv != NULL, RET_BAD_PARAMS);
for (i = 0; i < argc; i++) {
TKMEM_FREE(argv[i]);
}
TKMEM_FREE(argv);
return RET_OK;
}
static const char* str_skip_xint(const char* str) {
if (*str == '+' || *str == '-') {
str++;
}
while (*str && tk_isxdigit(*str)) {
str++;
}
return str;
}
static const char* str_skip_int(const char* str) {
if (*str == '+' || *str == '-') {
str++;
}
while (*str && tk_isdigit(*str)) {
str++;
}
return str;
}
static const char* str_skip_float(const char* str) {
if (*str == '+' || *str == '-') {
str++;
}
while (*str && tk_isdigit(*str)) {
str++;
}
if (*str == '.' || *str == 'e' || *str == 'E') {
str++;
if (*str == '+' || *str == '-') {
str++;
}
while (*str && tk_isdigit(*str)) {
str++;
}
}
return str;
}
int tk_vsscanf_simple(const char* str, const char* format, va_list args) {
int assignments = 0;
while (*format && *str) {
if (*format != '%') {
if (*format != *str) break;
format++;
str++;
} else {
/* 跳过 % */
format++;
/*跳过空白字符*/
while (isspace(*str)) str++;
if (tk_isdigit(*format)) {
/*%02x*/
/*%02d*/
int n = tk_atoi(format);
char temp[256] = {0};
const char* s = temp;
tk_strncpy(temp, str, tk_min_int(n, sizeof(temp) - 1));
while (tk_isdigit(*format)) format++;
switch (*format) {
case 'd': {
int* p = va_arg(args, int*);
*p = (int)tk_strtol(s, NULL, 10);
assignments++;
format++;
break;
}
case 'x': {
unsigned int* p = va_arg(args, unsigned int*);
*p = (unsigned int)tk_strtol(s, NULL, 16);
assignments++;
format++;
break;
}
case 'u': {
unsigned int* p = va_arg(args, unsigned int*);
*p = (unsigned int)tk_strtol(s, NULL, 10);
assignments++;
format++;
break;
}
case 's': {
char* p = va_arg(args, char*);
tk_strcpy(p, temp);
assignments++;
format++;
break;
}
default: {
log_warn("tk_sscanf_simple: not support %s\n", format);
format++;
break;
}
}
str += n;
continue;
}
switch (*format) {
case 'u': {
unsigned int* p = va_arg(args, unsigned int*);
*p = (uint32_t)tk_strtol(str, NULL, 10);
str = str_skip_int(str);
assignments++;
format++;
break;
}
case 'd': {
int* p = va_arg(args, int*);
*p = (int)tk_strtol(str, NULL, 10);
str = str_skip_int(str);
assignments++;
format++;
break;
}
case 'f': {
float* p = va_arg(args, float*);
*p = (float)tk_atof(str);
str = str_skip_float(str);
assignments++;
format++;
break;
}
case 'x': {
unsigned int* p = va_arg(args, unsigned int*);
*p = (unsigned int)tk_strtol(str, NULL, 16);
str = str_skip_xint(str);
assignments++;
format++;
break;
}
case 'p': {
void** p = va_arg(args, void**);
if (strncasecmp(str, "0x", 2) == 0) {
str += 2;
}
*p = (void*)tk_strtol(str, NULL, 16);
str = str_skip_xint(str);
assignments++;
format++;
break;
}
case 'l': {
format++;
if (*format == 'd') {
long* p = va_arg(args, long*);
*p = (long)tk_strtol(str, NULL, 10);
str = str_skip_int(str);
assignments++;
} else if (*format == 'u') {
unsigned long* p = va_arg(args, unsigned long*);
*p = (unsigned long)tk_strtol(str, NULL, 10);
str = str_skip_int(str);
assignments++;
assignments++;
} else if (*format == 'f') {
double* p = va_arg(args, double*);
*p = (double)tk_atof(str);
str = str_skip_float(str);
assignments++;
}
format++;
break;
}
default:
break;
}
}
}
return assignments;
}
int tk_sscanf_simple(const char* str, const char* format, ...) {
int ret = 0;
va_list va;
va_start(va, format);
ret = tk_vsscanf_simple(str, format, va);
va_end(va);
return ret;
}
#ifdef HAS_NO_VSSCANF
int sscanf(const char* str, const char* format, ...) {
int ret = 0;
va_list va;
va_start(va, format);
ret = tk_vsscanf_simple(str, format, va);
va_end(va);
return ret;
}
int vsscanf(const char* str, const char* format, va_list args) {
return tk_vsscanf_simple(str, format, args);
}
int tk_sscanf(const char* str, const char* format, ...) {
int ret = 0;
va_list va;
va_start(va, format);
ret = tk_vsscanf_simple(str, format, va);
va_end(va);
return ret;
}
#else
int tk_sscanf(const char* str, const char* format, ...) {
int ret = 0;
va_list va;
va_start(va, format);
ret = vsscanf(str, format, va);
va_end(va);
return ret;
}
#endif /*HAS_NO_VSSCANF*/
int32_t tk_levelize(const char* levels, int32_t value) {
int32_t level = 0;
int32_t start = 0;
int32_t end = 0;
const char* p = levels;
return_value_if_fail(levels != NULL, 0);
while (*p) {
if (tk_sscanf(p, "%d-%d", &start, &end) == 2) {
if (value < start) {
break;
}
if (value >= start && value <= end) {
return level;
}
}
p = strchr(p, ';');
if (p != NULL) {
p = p + 1;
level++;
} else {
break;
}
}
return level;
}
#include "tkc/date_time.h"
static uint32_t tk_count_repeat_char(const char* str, char c) {
uint32_t nr = 0;
return_value_if_fail(str != NULL, 0);
while (*str++ == c) {
nr++;
if (*str == '\0') {
break;
}
}
return nr;
}
ret_t tk_date_time_format(uint64_t time, const char* format, str_t* result) {
date_time_t dt;
wchar_t temp[32];
const char* p = format;
return_value_if_fail(format != NULL && result != NULL, RET_BAD_PARAMS);
str_clear(result);
date_time_init(&dt);
date_time_from_time(&dt, time);
memset(temp, 0x00, sizeof(temp));
while (*p) {
int32_t repeat = tk_count_repeat_char(p, *p);
switch (*p) {
case 'Y': {
if (repeat == 2) {
str_append_format(result, 32, "%02d", dt.year % 100);
} else {
str_append_format(result, 32, "%d", dt.year);
}
break;
}
case 'M': {
if (repeat == 2) {
str_append_format(result, 32, "%02d", dt.month);
} else {
str_append_format(result, 32, "%d", dt.month);
}
break;
}
case 'D': {
if (repeat == 2) {
str_append_format(result, 32, "%02d", dt.day);
} else {
str_append_format(result, 32, "%d", dt.day);
}
break;
}
case 'h': {
if (repeat == 2) {
str_append_format(result, 32, "%02d", dt.hour);
} else {
str_append_format(result, 32, "%d", dt.hour);
}
break;
}
case 'H': {
if (repeat == 2) {
if (dt.hour == 0) {
str_append_format(result, 32, "%02d", 12);
} else {
str_append_format(result, 32, "%02d", ((dt.hour > 12) ? (dt.hour - 12) : (dt.hour)));
}
} else {
if (dt.hour == 0) {
str_append_format(result, 32, "%d", 12);
} else {
str_append_format(result, 32, "%d", ((dt.hour > 12) ? (dt.hour - 12) : (dt.hour)));
}
}
break;
}
case 'm': {
if (repeat == 2) {
str_append_format(result, 32, "%02d", dt.minute);
} else {
str_append_format(result, 32, "%d", dt.minute);
}
break;
}
case 's': {
if (repeat == 2) {
str_append_format(result, 32, "%02d", dt.second);
} else {
str_append_format(result, 32, "%d", dt.second);
}
break;
}
default: {
str_append_with_len(result, p, repeat);
break;
}
}
p += repeat;
}
return RET_OK;
}
uint32_t tk_bits_to_bytes(uint32_t bits) {
return (bits + 7) / 8;
}
ret_t tk_bits_data_from_bytes_data(uint8_t* bits, uint32_t bits_size, uint8_t* bytes,
uint32_t bytes_size) {
uint32_t i = 0;
for (i = 0; i < bytes_size; i++) {
bits_stream_set(bits, bits_size, i, bytes[i] != 0);
}
return RET_OK;
}
ret_t tk_bits_data_to_bytes_data(uint8_t* bits, uint32_t bits_size, uint8_t* bytes,
uint32_t bytes_size) {
uint32_t i = 0;
for (i = 0; i < bytes_size; i++) {
bool_t value = FALSE;
if (bits_stream_get(bits, bits_size, i, &value) == RET_OK) {
bytes[i] = value ? 1 : 0;
}
}
return RET_OK;
}
uint32_t tk_size_of_basic_type(value_type_t type) {
switch (type) {
case VALUE_TYPE_INT8:
case VALUE_TYPE_STRING:
case VALUE_TYPE_BINARY:
case VALUE_TYPE_UINT8:
case VALUE_TYPE_BOOL:
return 1;
case VALUE_TYPE_INT16:
case VALUE_TYPE_UINT16:
return 2;
case VALUE_TYPE_INT32:
case VALUE_TYPE_UINT32:
case VALUE_TYPE_FLOAT32:
return 4;
case VALUE_TYPE_INT64:
case VALUE_TYPE_UINT64:
case VALUE_TYPE_DOUBLE:
return 8;
default:
break;
}
return 0;
}
uint8_t* tk_skip_to_offset(uint8_t* data, uint32_t size, value_type_t type, int16_t index) {
uint32_t type_size = tk_size_of_basic_type(type);
uint32_t offset = index * type_size;
return_value_if_fail(data != NULL && type_size > 0, NULL);
return_value_if_fail((offset + type_size) <= size, NULL);
return data + offset;
}
ret_t tk_buffer_set_value(uint8_t* buffer, uint32_t size, value_type_t type, int16_t offset,
int16_t bit_offset, const value_t* value) {
uint32_t type_size = tk_size_of_basic_type(type);
uint8_t* data = tk_skip_to_offset(buffer, size, type, offset);
return_value_if_fail(data != NULL, RET_BAD_PARAMS);
if (bit_offset >= 0) {
return_value_if_fail(bit_offset < type_size * 8, RET_BAD_PARAMS);
return bits_stream_set(data, type_size, bit_offset, value_bool(value));
}
switch (type) {
case VALUE_TYPE_INT8: {
*data = value_int8(value);
break;
}
case VALUE_TYPE_UINT8: {
*data = value_uint8(value);
break;
}
case VALUE_TYPE_INT16: {
int16_t v = value_int16(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_UINT16: {
uint16_t v = value_uint16(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_INT32: {
int32_t v = value_int32(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_UINT32: {
uint32_t v = value_uint32(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_INT64: {
int64_t v = value_int64(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_UINT64: {
uint64_t v = value_uint64(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_FLOAT32: {
float v = value_float32(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_DOUBLE: {
double v = value_double(value);
memcpy(data, &v, sizeof(v));
break;
}
case VALUE_TYPE_STRING: {
const char* str = value_str(value);
int32_t dst_len = size - (data - buffer);
int32_t src_len = tk_strlen(str) + 1;
return_value_if_fail(str != NULL, RET_BAD_PARAMS);
return_value_if_fail(dst_len >= src_len, RET_BAD_PARAMS);
memcpy(data, str, src_len);
break;
}
case VALUE_TYPE_BINARY: {
binary_data_t* bdata = value_binary_data(value);
int32_t dst_len = size - (data - buffer);
return_value_if_fail(bdata != NULL, RET_BAD_PARAMS);
return_value_if_fail(dst_len >= bdata->size, RET_BAD_PARAMS);
memcpy(data, bdata->data, bdata->size);
break;
}
default: {
log_debug("tk_buffer_set_value: not support %d\n", type);
return RET_NOT_IMPL;
}
}
return RET_OK;
}
ret_t tk_buffer_get_value(uint8_t* buffer, uint32_t size, value_type_t type, int16_t offset,
int16_t bit_offset, value_t* value) {
bool_t v = FALSE;
uint32_t type_size = tk_size_of_basic_type(type);
uint8_t* data = tk_skip_to_offset(buffer, size, type, offset);
return_value_if_fail(data != NULL, RET_BAD_PARAMS);
return_value_if_fail(type_size > 0, RET_BAD_PARAMS);
if (bit_offset >= 0) {
return_value_if_fail(bit_offset < type_size * 8, RET_BAD_PARAMS);
bits_stream_get(data, type_size, bit_offset, &v);
value_set_bool(value, v);
return RET_OK;
}
switch (type) {
case VALUE_TYPE_INT8: {
value_set_int8(value, *data);
break;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(value, *data);
break;
}
case VALUE_TYPE_INT16: {
int16_t v = 0;
memcpy(&v, data, sizeof(v));
value_set_int16(value, v);
break;
}
case VALUE_TYPE_UINT16: {
uint16_t v = 0;
memcpy(&v, data, sizeof(v));
value_set_uint16(value, v);
break;
}
case VALUE_TYPE_INT32: {
int32_t v = 0;
memcpy(&v, data, sizeof(v));
value_set_int32(value, v);
break;
}
case VALUE_TYPE_UINT32: {
uint32_t v = 0;
memcpy(&v, data, sizeof(v));
value_set_uint32(value, v);
break;
}
case VALUE_TYPE_INT64: {
int64_t v = 0;
memcpy(&v, data, sizeof(v));
value_set_int64(value, v);
break;
}
case VALUE_TYPE_UINT64: {
uint64_t v = 0;
memcpy(&v, data, sizeof(v));
value_set_uint64(value, v);
break;
}
case VALUE_TYPE_FLOAT32: {
float v = 0;
memcpy(&v, data, sizeof(v));
value_set_float32(value, v);
break;
}
case VALUE_TYPE_DOUBLE: {
double v = 0;
memcpy(&v, data, sizeof(v));
value_set_double(value, v);
break;
}
case VALUE_TYPE_STRING: {
value_set_str(value, (char*)data);
break;
}
case VALUE_TYPE_BINARY: {
uint32_t bsize = size - (data - buffer);
value_set_binary_data(value, data, bsize);
break;
}
default: {
log_debug("tk_buffer_get_value: not support %d\n", type);
return RET_NOT_IMPL;
}
}
return RET_OK;
}
value_type_t tk_basic_type_from_name(const char* type) {
if (strncasecmp(type, "int8", 4) == 0) {
return VALUE_TYPE_INT8;
} else if (strncasecmp(type, "bool", 4) == 0) {
return VALUE_TYPE_BOOL;
} else if (strncasecmp(type, "int16", 5) == 0) {
return VALUE_TYPE_INT16;
} else if (strncasecmp(type, "int32", 5) == 0) {
return VALUE_TYPE_INT32;
} else if (strncasecmp(type, "int64", 5) == 0) {
return VALUE_TYPE_INT64;
} else if (strncasecmp(type, "uint8", 5) == 0 || strncasecmp(type, "byte", 4) == 0) {
return VALUE_TYPE_UINT8;
} else if (strncasecmp(type, "uint16", 6) == 0 || strncasecmp(type, "word", 4) == 0) {
return VALUE_TYPE_UINT16;
} else if (strncasecmp(type, "uint32", 6) == 0 || strncasecmp(type, "dword", 5) == 0) {
return VALUE_TYPE_UINT32;
} else if (strncasecmp(type, "uint64", 6) == 0 || strncasecmp(type, "lword", 5) == 0) {
return VALUE_TYPE_UINT64;
} else if (strncasecmp(type, "float", 5) == 0) {
return VALUE_TYPE_FLOAT32;
} else if (strncasecmp(type, "double", 6) == 0) {
return VALUE_TYPE_DOUBLE;
} else if (strncasecmp(type, "str", 3) == 0) {
return VALUE_TYPE_STRING;
} else if (strncasecmp(type, "wstr", 4) == 0) {
return VALUE_TYPE_WSTRING;
} else if (strncasecmp(type, "bin", 3) == 0) {
return VALUE_TYPE_BINARY;
}
return VALUE_TYPE_INVALID;
}
uint32_t tk_distance(int x1, int y1, int x2, int y2) {
return (uint32_t)sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
double tk_value_to_angle(double value, double min, double max, double start_angle, double end_angle,
bool_t counter_clock_wise) {
double offset_angle = 0;
double range = max - min;
double range_angle = 0;
return_value_if_fail(range > 0, 0);
start_angle = TK_D2R(start_angle);
end_angle = TK_D2R(end_angle);
range_angle = end_angle - start_angle;
value = tk_clamp(value, min, max);
offset_angle = (range_angle / range) * (value - min);
if (counter_clock_wise) {
return end_angle - offset_angle;
} else {
return start_angle + offset_angle;
}
return end_angle;
}
double tk_angle(int cx, int cy, int x, int y) {
double angle = 0;
double dx = x - cx;
double dy = -(y - cy);
if (dx == 0) {
if (dy > 0) {
angle = M_PI / 2;
} else {
angle = -M_PI / 2;
}
} else {
angle = atan2(dy, dx);
}
if (angle < 0) {
angle = angle + 2 * M_PI;
}
return angle;
}
const char* tk_skip_chars(const char* str, const char* chars) {
return_value_if_fail(str != NULL && chars != NULL, str);
while (*str && strchr(chars, *str) != NULL) {
str++;
}
return str;
}
const char* tk_skip_to_chars(const char* str, const char* chars) {
return_value_if_fail(str != NULL && chars != NULL, str);
while (*str && strchr(chars, *str) == NULL) {
str++;
}
return str;
}
static void merge(void* base, size_t size, tk_compare_t cmp, void* left,
size_t leftSize, void* right, size_t rightSize) {
// 创建临时数组
void* temp = TKMEM_ALLOC((leftSize + rightSize) * size);
if (temp == NULL) {
log_warn("Memory allocation failed\n");
return;
}
size_t i = 0, j = 0, k = 0;
// 归并两个子数组
while (i < leftSize && j < rightSize) {
if (cmp((char*)left + i * size, (char*)right + j * size) <= 0) {
memcpy((char*)temp + k * size, (char*)left + i * size, size);
i++;
} else {
memcpy((char*)temp + k * size, (char*)right + j * size, size);
j++;
}
k++;
}
// 复制剩余的左边部分
while (i < leftSize) {
memcpy((char*)temp + k * size, (char*)left + i * size, size);
i++;
k++;
}
// 复制剩余的右边部分
while (j < rightSize) {
memcpy((char*)temp + k * size, (char*)right + j * size, size);
j++;
k++;
}
// 将排序后的内容复制回原数组
memcpy(base, temp, (leftSize + rightSize) * size);
TKMEM_FREE(temp);
}
static void tk_mergesort_impl(void* base, size_t nmemb, size_t size,
tk_compare_t cmp) {
if (nmemb < 2) return; // 如果只有一个元素，不需要排序
size_t mid = nmemb / 2;
// 递归排序左半部分
tk_mergesort_impl(base, mid, size, cmp);
// 递归排序右半部分
tk_mergesort_impl((char*)base + mid * size, nmemb - mid, size, cmp);
// 归并排序的结果
void* left = base;
void* right = (char*)base + mid * size;
// 计算左右部分的大小
size_t leftSize = mid;
size_t rightSize = nmemb - mid;
// 合并两个已排序的部分
merge(base, size, cmp, left, leftSize, right, rightSize);
}
ret_t tk_mergesort(void* base, size_t nmemb, size_t size, tk_compare_t cmp) {
return_value_if_fail(cmp != NULL, RET_BAD_PARAMS);
return_value_if_fail(base != NULL&& nmemb != 0 && size != 0, RET_BAD_PARAMS);
tk_mergesort_impl(base, nmemb, size, cmp);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/thread.h
|
/**
* File: thread.h
* Author: AWTK Develop Team
* Brief: thread
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-05-18 Li XianJing <[email protected]> created
*
*/
#ifndef TK_THREAD_H
#define TK_THREAD_H
#include "tkc/types_def.h"
/**
* @class tk_thread_t
* 线程对象。
*/
struct _tk_thread_t;
typedef struct _tk_thread_t tk_thread_t;
typedef void* (*tk_thread_entry_t)(void* args);
BEGIN_C_DECLS
typedef enum _tk_thread_priority_t {
TK_THREAD_PRIORITY_NORMAL = 0x0,
TK_THREAD_PRIORITY_IDLE,
TK_THREAD_PRIORITY_LOWEST,
TK_THREAD_PRIORITY_BELOW_NORAML,
TK_THREAD_PRIORITY_ABOVE_NORAML,
TK_THREAD_PRIORITY_HIGHEST,
TK_THREAD_PRIORITY_TIME_CRITICAL,
} tk_thread_priority_t;
/**
* @method tk_thread_create
* 创建thread对象。
*
* @param {tk_thread_entry_t} entry 线程函数。
* @param {void*} args 线程函数的上下文。
*
* @return {tk_thread_t*} thread对象。
*/
tk_thread_t* tk_thread_create(tk_thread_entry_t entry, void* args);
/**
* @method tk_thread_set_name
* 设置线程的名称。
*
* > 需要在调用start之前调用本函数。
* @param {tk_thread_t*} thread thread对象。
* @param {const char*} name 名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_thread_set_name(tk_thread_t* thread, const char* name);
/**
* @method tk_thread_set_stack_size
* 设置线程的栈大小。
*
* > 需要在调用start之前调用本函数。
* @param {tk_thread_t*} thread thread对象。
* @param {uint32_t} stack_size 栈的大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_thread_set_stack_size(tk_thread_t* thread, uint32_t stack_size);
/**
* @method tk_thread_set_priority
* 设置线程的优先级。
*
* > 部分平台支持。
* @param {tk_thread_t*} thread thread对象。
* @param {tk_thread_priority_t} priority 优先级。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_thread_set_priority(tk_thread_t* thread, tk_thread_priority_t priority);
/**
* @method tk_thread_get_priority_from_platform
* 获取平台相关的优先级
*
* > 部分平台支持。
* > 根据 AWTK 通用优先级枚举获取平台相关的优先级
* @annotation ["static"]
* @param {tk_thread_priority_t} priority 优先级。
*
* @return {int32_t} 返回平台相关的优先级。
*/
int32_t tk_thread_get_priority_from_platform(tk_thread_priority_t priority);
/**
* @method tk_thread_start
* 启动线程。
* @param {tk_thread_t*} thread thread对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_thread_start(tk_thread_t* thread);
/**
* @method tk_thread_join
* 等待线程退出。
* 必须调用 tk_thread_destroy 函数来释放线程资源，以免出现内存泄漏的问题。
* @param {tk_thread_t*} thread thread对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_thread_join(tk_thread_t* thread);
/**
* @method tk_thread_get_args
* 获取线程的参数。
* @param {tk_thread_t*} thread thread对象。
*
* @return {void*} 返回线程的参数。
*/
void* tk_thread_get_args(tk_thread_t* thread);
/**
* @method tk_thread_destroy
* 销毁thread对象。
* 在销毁对象前必须调用 tk_thread_join 函数等待退出线程
* @param {tk_thread_t*} thread thread对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_thread_destroy(tk_thread_t* thread);
/**
* @method tk_thread_self
* 获取当前线程的原生句柄。
*
* @return {uint64_t} 返回当前线程的原生句柄。
*/
uint64_t tk_thread_self(void);
END_C_DECLS
#endif /*TK_THREAD_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/value_desc.c
|
/**
* File: value_desc.c
* Author: AWTK Develop Team
* Brief: value_desc
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-25 Li XianJing <[email protected]> created
*
*/
#include "tkc/utils.h"
#include "tkc/value_desc.h"
ret_t value_desc_validate(value_desc_t* schema, value_t* v) {
return_value_if_fail(v != NULL && schema != NULL, RET_BAD_PARAMS);
switch (schema->type) {
case VALUE_DESC_TYPE_INT8: {
int32_t value = value_int(v);
const value_desc_int8_t* desc = (const value_desc_int8_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_INT16: {
int32_t value = value_int(v);
const value_desc_int16_t* desc = (const value_desc_int16_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_INT32: {
int32_t value = value_int(v);
const value_desc_int32_t* desc = (const value_desc_int32_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_INT64: {
int64_t value = value_int64(v);
const value_desc_int64_t* desc = (const value_desc_int64_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_UINT8: {
int32_t value = value_int(v);
const value_desc_uint8_t* desc = (const value_desc_uint8_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_UINT16: {
int32_t value = value_int(v);
const value_desc_uint16_t* desc = (const value_desc_uint16_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_UINT32: {
uint32_t value = value_uint32(v);
const value_desc_uint32_t* desc = (const value_desc_uint32_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_UINT64: {
uint64_t value = value_uint64(v);
const value_desc_uint64_t* desc = (const value_desc_uint64_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_STRING: {
uint32_t len = 0;
const char* value = value_str(v);
const value_desc_string_t* desc = (const value_desc_string_t*)schema;
return_value_if_fail(value != NULL, RET_FAIL);
len = strlen(value);
return_value_if_fail(len >= desc->min && len <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_FLOAT: {
float value = value_float32(v);
const value_desc_float_t* desc = (const value_desc_float_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_DOUBLE: {
double value = value_double(v);
const value_desc_double_t* desc = (const value_desc_double_t*)schema;
return_value_if_fail(value >= desc->min && value <= desc->max, RET_FAIL);
return RET_OK;
}
case VALUE_DESC_TYPE_STRING_ENUMS: {
uint32_t i = 0;
const char* value = value_str(v);
const value_desc_string_enums_t* desc = (const value_desc_string_enums_t*)schema;
return_value_if_fail(desc->enums != NULL && value != NULL, RET_FAIL);
for (i = 0; desc->enums[i] != NULL; i++) {
if (tk_str_eq(desc->enums[i], value)) {
return RET_OK;
}
}
break;
}
case VALUE_DESC_TYPE_INT_ENUMS: {
uint32_t i = 0;
int32_t value = value_int(v);
const value_desc_int_enums_t* desc = (const value_desc_int_enums_t*)schema;
return_value_if_fail(desc->enums != NULL, RET_FAIL);
for (i = 0; desc->enums[i] != NULL; i++) {
if (tk_atoi(desc->enums[i]) == value) {
return RET_OK;
}
}
break;
}
default:
break;
}
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/date_time.c
|
/**
* File: date_time.c
* Author: AWTK Develop Team
* Brief: date time
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/date_time.h"
static date_time_get_now_t s_date_time_get_now;
static date_time_set_now_t s_date_time_set_now;
static date_time_from_time_t s_date_time_from_time;
static date_time_to_time_t s_date_time_to_time;
ret_t date_time_global_init_ex(const date_time_vtable_t* vt) {
return_value_if_fail(vt != NULL, RET_BAD_PARAMS);
s_date_time_get_now = vt->get_now;
s_date_time_set_now = vt->set_now;
s_date_time_from_time = vt->from_time;
s_date_time_to_time = vt->to_time;
return RET_OK;
}
ret_t date_time_global_init(date_time_get_now_t get, date_time_set_now_t set) {
s_date_time_get_now = get;
s_date_time_set_now = set;
return RET_OK;
}
ret_t date_time_set_impl(date_time_get_now_t date_time_get_now) {
s_date_time_get_now = date_time_get_now;
return RET_OK;
}
date_time_t* date_time_create(void) {
date_time_t* dt = TKMEM_ZALLOC(date_time_t);
return date_time_init(dt);
}
ret_t date_time_from_time(date_time_t* dt, int64_t time) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
return_value_if_fail(s_date_time_from_time != NULL, RET_BAD_PARAMS);
return s_date_time_from_time(dt, (time_t)time);
}
date_time_t* date_time_init(date_time_t* dt) {
return_value_if_fail(dt != NULL, NULL);
memset(dt, 0x00, sizeof(date_time_t));
if (s_date_time_get_now != NULL) {
s_date_time_get_now(dt);
return dt;
} else {
return NULL;
}
}
ret_t date_time_set(date_time_t* dt) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
return_value_if_fail(s_date_time_set_now != NULL, RET_NOT_IMPL);
return s_date_time_set_now(dt);
}
ret_t date_time_destroy(date_time_t* dt) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
TKMEM_FREE(dt);
return RET_OK;
}
bool_t date_time_is_leap(uint32_t year) {
if ((year % 100) == 0) {
return (year % 400) == 0;
} else {
return (year % 4) == 0;
}
}
int32_t date_time_get_days(uint32_t year, uint32_t month) {
int days = 0;
int days_of_month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
return_value_if_fail(month >= 1 && month <= 12, -1);
days = days_of_month[month - 1];
if (days == 28) {
if (date_time_is_leap(year)) {
days = 29;
}
}
return days;
}
/**
* 实现参考：https://github.com/Franceskynov/zeller/blob/master/zeller.js
*/
int32_t date_time_get_wday(uint32_t year, uint32_t month, uint32_t day) {
int w = 0;
int a = 0;
int y = 0;
int m = 0;
return_value_if_fail(year <= 10000, -1);
return_value_if_fail(day >= 1 && day <= 31, -1);
return_value_if_fail(month >= 1 && month <= 12, -1);
return_value_if_fail(date_time_get_days(year, month) >= day && day > 0, -1);
a = ((14 - month) / 12);
y = (year - a);
m = (month + (12 * a) - 2);
w = (((day + y + (y / 4)) - (y / 100) + (y / 400) + (31 * m) / 12) % 7);
return w;
}
static const char* s_en_month_names[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sept", "Oct", "Nov", "Dec"};
const char* date_time_get_month_name(uint32_t month) {
return_value_if_fail(month >= 1 && month <= 12, NULL);
return s_en_month_names[month - 1];
}
static const char* s_en_wday_names[] = {
"Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat",
};
const char* date_time_get_wday_name(uint32_t wday) {
return_value_if_fail(wday <= 6, NULL);
return s_en_wday_names[wday];
}
ret_t date_time_add_delta(date_time_t* dt, int64_t delta) {
int64_t t = 0;
return_value_if_fail(dt != NULL && s_date_time_to_time != NULL, RET_BAD_PARAMS);
t = s_date_time_to_time(dt) + delta;
return s_date_time_from_time(dt, t);
}
int64_t date_time_to_time(date_time_t* dt) {
return_value_if_fail(dt != NULL && s_date_time_to_time != NULL, RET_BAD_PARAMS);
return s_date_time_to_time(dt);
}
ret_t date_time_set_year(date_time_t* dt, uint32_t year) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
dt->year = year;
dt->wday = date_time_get_wday(dt->year, dt->month, dt->day);
return RET_OK;
}
ret_t date_time_set_month(date_time_t* dt, uint32_t month) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
return_value_if_fail(month > 0 && month <= 31, RET_BAD_PARAMS);
dt->month = month;
dt->wday = date_time_get_wday(dt->year, dt->month, dt->day);
return RET_OK;
}
ret_t date_time_set_day(date_time_t* dt, uint32_t day) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
dt->day = day;
dt->wday = date_time_get_wday(dt->year, dt->month, dt->day);
return RET_OK;
}
ret_t date_time_set_hour(date_time_t* dt, uint32_t hour) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
return_value_if_fail(hour < 24, RET_BAD_PARAMS);
dt->hour = hour;
return RET_OK;
}
ret_t date_time_set_minute(date_time_t* dt, uint32_t minute) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
return_value_if_fail(minute < 60, RET_BAD_PARAMS);
dt->minute = minute;
return RET_OK;
}
ret_t date_time_set_second(date_time_t* dt, uint32_t second) {
return_value_if_fail(dt != NULL, RET_BAD_PARAMS);
return_value_if_fail(second < 60, RET_BAD_PARAMS);
dt->second = second;
return RET_OK;
}
ret_t date_time_parse_time(date_time_t* dt, const char* str) {
int32_t hour = 0;
int32_t minute = 0;
int32_t second = 0;
int32_t n = 0;
return_value_if_fail(dt != NULL && str != NULL, RET_BAD_PARAMS);
n = tk_sscanf(str, "%d:%d:%d", &hour, &minute, &second);
if (n >= 2) {
date_time_set_hour(dt, hour);
date_time_set_minute(dt, minute);
date_time_set_second(dt, second);
return RET_OK;
} else {
return RET_BAD_PARAMS;
}
}
ret_t date_time_parse_date(date_time_t* dt, const char* str) {
int32_t year = 0;
int32_t month = 0;
int32_t day = 0;
int32_t n = 0;
return_value_if_fail(dt != NULL && str != NULL, RET_BAD_PARAMS);
if (strchr(str, '/') != NULL) {
n = tk_sscanf(str, "%d/%d/%d", &year, &month, &day);
} else {
n = tk_sscanf(str, "%d-%d-%d", &year, &month, &day);
}
if (n == 3) {
date_time_set_year(dt, year);
date_time_set_month(dt, month);
date_time_set_day(dt, day);
return RET_OK;
} else {
return RET_BAD_PARAMS;
}
}
ret_t date_time_parse_date_time(date_time_t* dt, const char* str) {
int32_t year = 0;
int32_t month = 0;
int32_t day = 0;
int32_t hour = 0;
int32_t minute = 0;
int32_t second = 0;
int32_t n = 0;
return_value_if_fail(dt != NULL && str != NULL, RET_BAD_PARAMS);
if (strchr(str, '/') != NULL) {
n = tk_sscanf(str, "%d/%d/%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second);
} else {
n = tk_sscanf(str, "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second);
}
if (n >= 5) {
date_time_set_year(dt, year);
date_time_set_month(dt, month);
date_time_set_day(dt, day);
date_time_set_hour(dt, hour);
date_time_set_minute(dt, minute);
date_time_set_second(dt, second);
return RET_OK;
} else {
return RET_BAD_PARAMS;
}
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/state_machine.h
|
/**
* File: state_machine.h
* Author: AWTK Develop Team
* Brief: state_machine
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
*/
/**
* History:
* ================================================================
* 2020-12-29 Wang LinFu <[email protected]> 修改自 https://github.com/misje/stateMachine.git
*
*/
#ifndef TK_STATE_MACHINE_H
#define TK_STATE_MACHINE_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
typedef struct _tk_sm_state_t tk_sm_state_t;
typedef struct _tk_sm_event_t tk_sm_event_t;
/**
* @class tk_sm_event_t
* 状态机事件
*/
struct _tk_sm_event_t {
int type;
void* data;
};
/**
* @class tk_sm_transition_t
* 状态转换条件
*/
typedef struct {
int etype;
void* condition;
bool_t (*guard)(void* condition, tk_sm_event_t* event);
void (*action)(void* current_stat_data, tk_sm_event_t* event, void* new_state_data);
const tk_sm_state_t* next_state;
} tk_sm_transition_t;
/**
* @class tk_sm_state_t
* 状态结构体
*/
struct _tk_sm_state_t {
const tk_sm_state_t* base_state;
tk_sm_transition_t* transitions;
size_t ntransitions;
tk_sm_transition_t* transitions_back;
size_t ntransitions_back;
void* data;
void (*entry_action)(void* state_data, tk_sm_event_t* event);
void (*exit_action)(void* state_data, tk_sm_event_t* event);
};
/**
* @class tk_state_machine_t
* 状态机结构体
*/
typedef struct {
const tk_sm_state_t* current_state;
const tk_sm_state_t* previous_state;
} tk_state_machine_t;
/**
* @method tk_state_machine_init
* 初始化
*
* @param {tk_state_machine_t*} fsm 状态机地址
* @param {const tk_sm_state_t*} initial_state 初始状态
*
* @return {ret_t} 返回 ret_t 值
*/
ret_t tk_state_machine_init(tk_state_machine_t* fsm, const tk_sm_state_t* initial_state);
/**
* @method tk_state_machine_handle
* 事件处理
*
* @param {tk_state_machine_t*} fsm 状态机地址
* @param {tk_sm_event_t*} event 事件
*
* @return {ret_t} 返回 ret_t 值
*/
ret_t tk_state_machine_handle(tk_state_machine_t* fsm, tk_sm_event_t* event);
/**
* @method tk_state_machine_previous_get
* 获取上一个状态
*
* @param {tk_state_machine_t*} fsm 状态机地址
*
* @return {const tk_sm_state_t*} 返回 tk_sm_state_t 对象
*/
const tk_sm_state_t* tk_state_machine_previous_get(tk_state_machine_t* fsm);
/**
* @method tk_state_machine_current_get
* 获取当前状态
*
* @param {tk_state_machine_t*} fsm 状态机地址
*
* @return {const tk_sm_state_t*} 返回 tk_sm_state_t 对象
*/
const tk_sm_state_t* tk_state_machine_current_get(tk_state_machine_t* fsm);
/**
* @method tk_state_machine_deinit
* 反初始化
*
* @param {tk_state_machine_t*} fsm 状态机地址
* @param {tk_sm_event_t*} event 事件
*
* @return {ret_t} 返回 ret_t 值
*/
ret_t tk_state_machine_deinit(tk_state_machine_t* fsm, tk_sm_event_t* event);
END_C_DECLS
#endif /*TK_STATE_MACHINE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_writer.c
|
/**
* File: data_writer.c
* Author: AWTK Develop Team
* Brief: data_writer
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-26 Li XianJing <[email protected]> created
*
*/
#include "tkc/data_writer.h"
#include "tkc/data_writer_factory.h"
int32_t data_writer_write(data_writer_t* writer, uint64_t offset, const void* data, uint32_t size) {
return_value_if_fail(writer != NULL && writer->vt != NULL && writer->vt->write != NULL, -1);
return_value_if_fail(data != NULL && size > 0, -1);
return writer->vt->write(writer, offset, data, size);
}
ret_t data_writer_truncate(data_writer_t* writer, uint64_t size) {
return_value_if_fail(writer != NULL && writer->vt != NULL && writer->vt->truncate != NULL,
RET_BAD_PARAMS);
return writer->vt->truncate(writer, size);
}
ret_t data_writer_flush(data_writer_t* writer) {
return_value_if_fail(writer != NULL && writer->vt != NULL && writer->vt->flush != NULL,
RET_BAD_PARAMS);
return writer->vt->flush(writer);
}
ret_t data_writer_destroy(data_writer_t* writer) {
return_value_if_fail(writer != NULL && writer->vt != NULL && writer->vt->destroy != NULL,
RET_BAD_PARAMS);
return writer->vt->destroy(writer);
}
ret_t data_writer_clear(const char* url) {
ret_t ret = RET_OK;
data_writer_t* writer = data_writer_factory_create_writer(data_writer_factory(), url);
return_value_if_fail(writer != NULL, RET_BAD_PARAMS);
ret = data_writer_truncate(writer, 0);
data_writer_destroy(writer);
return ret;
}
int32_t data_writer_write_all(const char* url, const void* data, uint32_t size) {
int32_t s = 0;
data_writer_t* writer = data_writer_factory_create_writer(data_writer_factory(), url);
return_value_if_fail(writer != NULL, -1);
s = data_writer_write(writer, 0, data, size);
data_writer_destroy(writer);
return s;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/fscript.c
|
/**
* File: fscript.c
* Author: AWTK Develop Team
* Brief: a simple script language
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
*/
/**
* History:
* ================================================================
* 2020-11-09 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utf8.h"
#include "tkc/utils.h"
#include "tkc/darray.h"
#include "tkc/fscript.h"
#include "tkc/int_str.h"
#include "tkc/buffer.h"
#include "tkc/object_default.h"
#include "tkc/general_factory.h"
#include "tkc/object_locker.h"
#ifndef WITHOUT_FSCRIPT
#define value_id_index(v) (v)->value.id.index
#define value_id_suboffset(v) (v)->value.id.suboffset
static tk_object_t* s_global_obj = NULL;
static tk_object_t* s_consts_obj = NULL;
static const fscript_hooks_t* s_hooks;
static ret_t fscript_locals_create(fscript_t* fscript, const char* name, const value_t* v);
static ret_t fscript_hook_on_init(fscript_t* fscript, const char* code) {
const fscript_hooks_t* hooks = fscript->hooks != NULL ? fscript->hooks : s_hooks;
if (hooks != NULL && hooks->on_init != NULL) {
return hooks->on_init(fscript, code);
}
return RET_OK;
}
static ret_t fscript_hook_on_deinit(fscript_t* fscript) {
const fscript_hooks_t* hooks = fscript->hooks != NULL ? fscript->hooks : s_hooks;
if (hooks != NULL && hooks->on_deinit != NULL) {
return hooks->on_deinit(fscript);
}
return RET_OK;
}
static ret_t fscript_hook_before_exec(fscript_t* fscript) {
const fscript_hooks_t* hooks = fscript->hooks != NULL ? fscript->hooks : s_hooks;
if (hooks != NULL && hooks->before_exec != NULL) {
return hooks->before_exec(fscript);
}
return RET_OK;
}
static ret_t fscript_hook_after_exec(fscript_t* fscript) {
const fscript_hooks_t* hooks = fscript->hooks != NULL ? fscript->hooks : s_hooks;
if (hooks != NULL && hooks->after_exec != NULL) {
return hooks->after_exec(fscript);
}
return RET_OK;
}
static ret_t fscript_hook_set_var(fscript_t* fscript, const char* name, const value_t* v) {
const fscript_hooks_t* hooks = fscript->hooks != NULL ? fscript->hooks : s_hooks;
if (hooks != NULL && hooks->set_var != NULL) {
return hooks->set_var(fscript, name, v);
}
return RET_NOT_IMPL;
}
static ret_t fscript_hook_exec_func(fscript_t* fscript, const char* name, fscript_func_call_t* iter,
value_t* result) {
const fscript_hooks_t* hooks = fscript->hooks != NULL ? fscript->hooks : s_hooks;
if (hooks != NULL && hooks->exec_func != NULL) {
return hooks->exec_func(fscript, name, iter, result);
}
return RET_NOT_IMPL;
}
ret_t fscript_set_hooks(const fscript_hooks_t* hooks) {
s_hooks = hooks;
return RET_OK;
}
ret_t fscript_set_self_hooks(fscript_t* fscript, const fscript_hooks_t* hooks) {
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
fscript->hooks = hooks;
return RET_OK;
}
static ret_t func_function_def(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_if(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_while(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_until(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_repeat_times(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_repeat(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_for(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_for_in(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_noop(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_pending(fscript_t* fscript, fscript_args_t* args, value_t* result) {
return RET_OK;
}
static ret_t func_return(fscript_t* fscript, fscript_args_t* args, value_t* result) {
if (args->size > 0) {
value_deep_copy(result, args->args);
}
fscript->returned = TRUE;
return RET_OK;
}
static ret_t func_get(fscript_t* fscript, fscript_args_t* args, value_t* result);
static ret_t func_set(fscript_t* fscript, fscript_args_t* args, value_t* result);
static ret_t func_unset(fscript_t* fscript, fscript_args_t* args, value_t* result);
static ret_t func_set_local(fscript_t* fscript, fscript_args_t* args, value_t* result);
static ret_t fscript_func_call_init_func(fscript_func_call_t* call, tk_object_t* obj,
tk_object_t* funcs_def, const char* name, uint32_t size);
ret_t fscript_ensure_locals(fscript_t* fscript) {
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
if (fscript->locals == NULL) {
fscript->locals = darray_create(5, (tk_destroy_t)named_value_destroy,
(tk_compare_t)named_value_compare_by_name);
}
return fscript->locals != NULL ? RET_OK : RET_FAIL;
}
ret_t fscript_ensure_locals_by_symbols(fscript_t* fscript) {
value_t v;
uint32_t i = 0;
const char* id = NULL;
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
if (fscript->symbols != NULL) {
memset(&v, 0x00, sizeof(value_t));
for (i = 0; i < fscript->symbols->size; i++) {
id = (const char*)darray_get(fscript->symbols, i);
fscript_locals_create(fscript, id, &v);
}
}
return RET_OK;
}
static ret_t fscript_locals_remove(fscript_t* fscript, uint32_t index) {
named_value_t* nv = (named_value_t*)(fscript->locals->elms[index]);
return value_reset(&(nv->value));
}
static tk_object_t* fscript_locals_get_object(fscript_t* fscript, const char* name) {
named_value_t* nv = (named_value_t*)darray_find(fscript->locals, (void*)name);
return nv != NULL ? value_object(&(nv->value)) : NULL;
}
static ret_t fscript_locals_get(fscript_t* fscript, const value_t* name, value_t* v) {
int32_t index = value_id_index(name);
int32_t suboffset = value_id_suboffset(name);
named_value_t* nv = (named_value_t*)(fscript->locals->elms[index]);
return_value_if_fail(nv != NULL, RET_FAIL);
if (!suboffset) {
return value_copy(v, &(nv->value));
} else {
tk_object_t* obj = value_object(&(nv->value));
const char* subname = value_id(name) + suboffset;
return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
return tk_object_get_prop(obj, subname, v);
}
}
static ret_t fscript_locals_set_with_index(fscript_t* fscript, uint32_t index, const value_t* v) {
named_value_t* nv = (named_value_t*)(fscript->locals->elms[index]);
if (nv->value.free_handle) {
value_reset(&(nv->value));
}
return value_deep_copy(&(nv->value), v);
}
static ret_t fscript_locals_set(fscript_t* fscript, const value_t* name, value_t* v) {
int32_t index = value_id_index(name);
int32_t suboffset = value_id_suboffset(name);
named_value_t* nv = (named_value_t*)(fscript->locals->elms[index]);
if (!suboffset) {
return fscript_locals_set_with_index(fscript, index, v);
} else {
tk_object_t* obj = value_object(&(nv->value));
const char* subname = value_id(name) + suboffset;
return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
return tk_object_set_prop(obj, subname, v);
}
}
static ret_t fscript_locals_create(fscript_t* fscript, const char* name, const value_t* v) {
int32_t index = 0;
named_value_t* nv = NULL;
return_value_if_fail(fscript_ensure_locals(fscript) == RET_OK, RET_BAD_PARAMS);
index = darray_find_index(fscript->locals, (void*)name);
if (index >= 0) {
if (fscript->symbols != NULL && darray_find_index(fscript->symbols, (void*)name) < 0) {
fscript_set_error(fscript, RET_FAIL, "<>", "duplicated var name.");
}
return fscript_locals_set_with_index(fscript, index, v);
}
nv = named_value_create_ex(name, v);
return_value_if_fail(nv != NULL, RET_BAD_PARAMS);
if (darray_push_unique(fscript->locals, nv) != RET_OK) {
named_value_destroy(nv);
return RET_FAIL;
}
return RET_OK;
}
static ret_t fscript_locals_destroy(fscript_t* fscript) {
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
if (fscript->locals != NULL) {
darray_destroy(fscript->locals);
fscript->locals = NULL;
}
return RET_OK;
}
static ret_t fscript_exec_func(fscript_t* fscript, const char* name, fscript_func_call_t* iter,
value_t* result) {
ret_t ret = fscript_hook_exec_func(fscript, name, iter, result);
if (ret == RET_NOT_IMPL) {
ret = fscript_exec_func_default(fscript, iter, result);
}
return ret;
}
ret_t fscript_set_error(fscript_t* fscript, ret_t code, const char* func, const char* message) {
fscript->error_code = code;
fscript->error_message = tk_str_copy(fscript->error_message, message);
if (fscript->curr != NULL) {
fscript->error_func = fscript->curr;
fscript->error_row = fscript->curr->row;
fscript->error_col = fscript->curr->col;
if (code != RET_OK) {
log_debug("(%d:%d): %s code=%d %s\n", fscript->curr->row, fscript->curr->col, func, code,
message);
}
}
if (fscript->on_error != NULL) {
fscript->on_error(fscript->on_error_ctx, fscript);
}
return RET_OK;
}
ret_t fscript_set_on_error(fscript_t* fscript, fscript_on_error_t on_error, void* ctx) {
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
fscript->on_error = on_error;
fscript->on_error_ctx = ctx;
return RET_OK;
}
ret_t fscript_set_print_func(fscript_t* fscript, fscript_func_t print) {
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
fscript->print = print;
return RET_OK;
}
static bool_t value_is_digit(value_t* v) {
uint32_t type = 0;
bool_t ret = TRUE;
return_value_if_fail(v != NULL, FALSE);
type = v->type;
if (type == VALUE_TYPE_INVALID || type == VALUE_TYPE_POINTER || type == VALUE_TYPE_STRING ||
type == VALUE_TYPE_WSTRING || type == VALUE_TYPE_OBJECT || type == VALUE_TYPE_SIZED_STRING ||
type == VALUE_TYPE_BINARY || type == VALUE_TYPE_UBJSON) {
ret = FALSE;
}
return ret;
}
static ret_t func_args_extend(fscript_args_t* args) {
if (args->size < args->capacity) {
return RET_OK;
}
if (args->capacity < FSCRIPT_MAX_ARGS) {
value_t* new_args = NULL;
uint16_t capacity = args->capacity + 2;
capacity = tk_min(capacity, FSCRIPT_MAX_ARGS);
new_args = TKMEM_REALLOC(args->args, capacity * sizeof(value_t));
return_value_if_fail(new_args != NULL, RET_OOM);
args->args = new_args;
args->capacity = capacity;
return RET_OK;
}
return RET_FAIL;
}
static ret_t func_args_push(fscript_args_t* args, value_t* v) {
return_value_if_fail(v != NULL && func_args_extend(args) == RET_OK, RET_BAD_PARAMS);
args->args[args->size++] = *v;
v->free_handle = FALSE;
value_reset(v);
return RET_OK;
}
static ret_t func_args_init(fscript_args_t* args, uint16_t init_args_capacity) {
memset(args, 0x00, sizeof(fscript_args_t));
if (init_args_capacity > 0) {
args->args = TKMEM_ZALLOCN(value_t, init_args_capacity);
return_value_if_fail(args->args != NULL, RET_OOM);
args->capacity = init_args_capacity;
}
return RET_OK;
}
static ret_t fscript_func_call_destroy(fscript_func_call_t* call);
static ret_t func_args_reset(fscript_args_t* args) {
uint32_t i = 0;
for (i = 0; i < args->size; i++) {
value_t* v = args->args + i;
if (v->type == VALUE_TYPE_FSCRIPT_FUNC) {
fscript_func_call_destroy(value_func(v));
}
value_reset(args->args + i);
}
return RET_OK;
}
static ret_t func_args_deinit(fscript_args_t* args) {
func_args_reset(args);
TKMEM_FREE(args->args);
memset(args, 0x00, sizeof(fscript_args_t));
return RET_OK;
}
static ret_t fscript_func_call_destroy(fscript_func_call_t* call) {
fscript_func_call_t* iter = call;
fscript_func_call_t* next = NULL;
while (iter != NULL) {
if (iter->func == func_pending) {
TKMEM_FREE(iter->ctx);
}
next = iter->next;
func_args_deinit(&(iter->args));
TKMEM_FREE(iter);
iter = next;
}
return RET_OK;
}
static fscript_function_def_t* fscript_function_def_create(const char* name,
fscript_func_call_t* body) {
fscript_function_def_t* func = TKMEM_ZALLOC(fscript_function_def_t);
return_value_if_fail(func != NULL, NULL);
func->body = body;
func->name = tk_strdup(name);
darray_init(&(func->params), 3, default_destroy, NULL);
return func;
}
static ret_t fscript_function_def_destroy(fscript_function_def_t* func) {
return_value_if_fail(func != NULL, RET_BAD_PARAMS);
darray_deinit(&(func->params));
fscript_func_call_destroy(func->body);
TKMEM_FREE(func->name);
memset(func, 0x00, sizeof(fscript_function_def_t));
TKMEM_FREE(func);
return RET_OK;
}
static ret_t fscript_function_def_add_param(fscript_function_def_t* func, const char* name) {
return_value_if_fail(func != NULL, RET_BAD_PARAMS);
return darray_push(&(func->params), tk_strdup(name));
}
typedef enum _token_type_t {
TOKEN_ID = 1,
TOKEN_VAR,
TOKEN_FUNC,
TOKEN_RETURN,
TOKEN_FUNC_DEF,
TOKEN_STR,
TOKEN_NUMBER,
TOKEN_LPAREN,
TOKEN_RPAREN,
TOKEN_LBRACKET,
TOKEN_RBRACKET,
TOKEN_COMMA,
TOKEN_SEMICOLON,
/*for expr*/
TOKEN_QUESTION,
TOKEN_COLON,
TOKEN_EOF
} token_type_t;
typedef struct _token_t {
const char* token;
token_type_t type;
uint32_t size;
bool_t valid;
} token_t;
typedef struct _fscript_parser_t {
tk_object_t* obj;
token_t token;
char* code_id;
const char* str;
const char* cursor;
char c;
str_t temp;
uint16_t row;
uint16_t col;
tk_object_t* funcs_def;
fscript_func_call_t* first;
fscript_parser_error_t* error;
bool_t keep_func_name;
darray_t* symbols;
} fscript_parser_t;
static ret_t fexpr_parse(fscript_parser_t* parser, value_t* result);
static ret_t fscript_parse_statements(fscript_parser_t* parser, fscript_func_call_t* acall);
static fscript_func_call_t* fscript_func_call_create(fscript_parser_t* parser, const char* name,
uint32_t size);
static const int_str_t s_ret_enums[] = {{RET_OK, "OK"},
{RET_OOM, "OOM"},
{RET_FAIL, "FAIL"},
{RET_NOT_IMPL, "NOT_IMPL"},
{RET_QUIT, "QUIT"},
{RET_FOUND, "FOUND"},
{RET_BUSY, "BUSY"},
{RET_REMOVE, "REMOVE"},
{RET_REPEAT, "REPEAT"},
{RET_NOT_FOUND, "NOT_FOUND"},
{RET_DONE, "DONE"},
{RET_STOP, "STOP"},
{RET_SKIP, "SKIP"},
{RET_CONTINUE, "CONTINUE"},
{RET_OBJECT_CHANGED, "OBJECT_CHANGED"},
{RET_ITEMS_CHANGED, "ITEMS_CHANGED"},
{RET_BAD_PARAMS, "BAD_PARAMS"},
{RET_TIMEOUT, "TIMEOUT"},
{RET_CRC, "CRC"},
{RET_IO, "IO"},
{RET_EOS, "EOS"},
{RET_NOT_MODIFIED, "NOT_MODIFIED"}};
static ret_t ret_name_to_value(const char* name, value_t* v) {
uint32_t i = 0;
for (i = 0; i < ARRAY_SIZE(s_ret_enums); i++) {
const int_str_t* iter = s_ret_enums + i;
if (tk_str_eq(iter->value, name)) {
value_set_int32(v, iter->name);
return RET_OK;
}
}
value_set_int32(v, RET_FAIL);
return RET_NOT_FOUND;
}
static ret_t fscript_get_var(fscript_t* fscript, const char* name, value_t* value) {
if (tk_str_eq_with_len(name, "RET_", 4)) {
return ret_name_to_value(name + 4, value);
}
value_set_str(value, NULL);
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
if (*name == '$') {
name += 1;
}
if (strncmp(name, FSCRIPT_STR_GLOBAL_PREFIX, FSCRIPT_GLOBAL_PREFIX_LEN) == 0) {
return tk_object_get_prop(fscript_get_global_object(), name + FSCRIPT_GLOBAL_PREFIX_LEN, value);
}
return tk_object_get_prop(fscript->obj, name, value);
}
ret_t fscript_set_var_default(fscript_t* fscript, const char* name, const value_t* value) {
if (strncmp(name, FSCRIPT_STR_GLOBAL_PREFIX, FSCRIPT_GLOBAL_PREFIX_LEN) == 0) {
return tk_object_set_prop(fscript_get_global_object(), name + FSCRIPT_GLOBAL_PREFIX_LEN, value);
}
return tk_object_set_prop(fscript->obj, name, value);
}
ret_t fscript_set_var(fscript_t* fscript, const char* name, const value_t* value) {
ret_t ret = fscript_hook_set_var(fscript, name, value);
if (ret == RET_NOT_IMPL) {
ret = fscript_set_var_default(fscript, name, value);
}
return ret;
}
static ret_t fscript_eval_arg(fscript_t* fscript, fscript_func_call_t* iter, uint32_t i,
value_t* d) {
value_t v;
value_t* s = iter->args.args + i;
value_set_str(&v, NULL);
value_set_str(d, NULL);
if (s->type == VALUE_TYPE_FSCRIPT_ID) {
if ((iter->func == func_set_local || iter->func == func_set || iter->func == func_unset ||
iter->func == func_get) &&
i == 0) {
value_copy(d, s); /*func_set accept id/str as first param*/
} else {
const char* name = value_id(s);
ENSURE(name);
if (value_id_index(s) >= 0) {
return fscript_locals_get(fscript, s, d);
}
if (fscript->loop_count > 0) {
if (tk_str_eq(name, "break")) {
fscript->breaked = TRUE;
return RET_OK;
} else if (tk_str_eq(name, "continue")) {
fscript->continued = TRUE;
return RET_OK;
}
} else if (tk_str_eq(name, "return")) {
fscript->returned = TRUE;
value_set_int(d, 0);
return RET_OK;
} else if (*name == '.') {
value_copy(d, s);
return RET_OK;
}
if (tk_str_start_with(name, FSCRIPT_CONSTS_PREFIX)) {
name += sizeof(FSCRIPT_CONSTS_PREFIX) - 1;
if (tk_object_get_prop(s_consts_obj, name, d) == RET_OK) {
value_reset(s);
value_copy(s, d);
return RET_OK;
}
}
if (fscript_get_var(fscript, name, d) != RET_OK) {
if (name == NULL || *name != '$') {
char msg[128];
tk_snprintf(msg, sizeof(msg) - 1, "not found var %s", name);
fscript_set_error(fscript, RET_NOT_FOUND, "get_var", msg);
value_set_str(d, value_id(s));
} else if (*name == '$') {
value_reset(d);
}
}
}
} else if (s->type == VALUE_TYPE_FSCRIPT_FUNC) {
fscript_exec_func(fscript, NULL, value_func(s), d);
} else {
value_copy(d, s);
}
return RET_OK;
}
static ret_t fscript_exec_if(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
uint32_t i = 0;
uint32_t n = 0;
value_t condition;
return_value_if_fail(iter->args.size >= 2, RET_FAIL);
n = iter->args.size / 2;
for (i = 0; i < n; i++) {
value_set_bool(&condition, FALSE);
return_value_if_fail(fscript_eval_arg(fscript, iter, 2 * i, &condition) == RET_OK, RET_FAIL);
if (value_bool(&condition)) {
return fscript_eval_arg(fscript, iter, 2 * i + 1, result);
}
}
if ((2 * i) < iter->args.size) {
return fscript_eval_arg(fscript, iter, 2 * i, result);
} else {
value_set_int(result, 0);
return RET_OK;
}
}
static ret_t fscript_exec_loop_body(fscript_t* fscript, fscript_func_call_t* iter, uint32_t start,
value_t* result, bool_t* done) {
uint32_t i = 1;
for (i = start; i < iter->args.size; i++) {
value_reset(result);
fscript_eval_arg(fscript, iter, i, result);
if (fscript->breaked) {
*done = TRUE;
fscript->breaked = FALSE;
break;
} else if (fscript->returned) {
*done = TRUE;
} else if (fscript->continued) {
fscript->continued = FALSE;
break;
}
}
return RET_OK;
}
static ret_t fscript_exec_while_or_until(fscript_t* fscript, fscript_func_call_t* iter,
value_t* result, bool_t is_while) {
value_t condition;
bool_t done = FALSE;
FSCRIPT_FUNC_CHECK(iter->args.size > 1, RET_FAIL);
fscript->loop_count++;
value_set_int(&condition, 0);
while (!done && fscript_eval_arg(fscript, iter, 0, &condition) == RET_OK) {
if (is_while ? !value_bool(&condition) : value_bool(&condition)) {
break;
}
fscript_exec_loop_body(fscript, iter, 1, result, &done);
}
fscript->loop_count--;
return RET_OK;
}
/*repeat(a, 0, 100, 1) {*/
static ret_t fscript_exec_repeat(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
value_t v;
int32_t start = 0;
int32_t end = 0;
int32_t delta = 0;
bool_t done = FALSE;
value_t* var = iter->args.args;
int32_t index = value_id_index(var);
const char* name = value_id(iter->args.args);
FSCRIPT_FUNC_CHECK(iter->args.size > 4, RET_FAIL);
FSCRIPT_FUNC_CHECK(fscript_eval_arg(fscript, iter, 1, &v) == RET_OK, RET_BAD_PARAMS);
start = value_int(&v);
FSCRIPT_FUNC_CHECK(fscript_eval_arg(fscript, iter, 2, &v) == RET_OK, RET_BAD_PARAMS);
end = value_int(&v);
FSCRIPT_FUNC_CHECK(fscript_eval_arg(fscript, iter, 3, &v) == RET_OK, RET_BAD_PARAMS);
delta = value_int(&v);
fscript->loop_count++;
while ((start != end) && !done) {
value_set_int(&v, start);
if (index >= 0) {
break_if_fail(fscript_locals_set(fscript, var, &v) == RET_OK);
} else {
break_if_fail(fscript_set_var(fscript, name, &v) == RET_OK);
}
fscript_exec_loop_body(fscript, iter, 4, result, &done);
start += delta;
}
fscript->loop_count--;
return RET_OK;
}
static ret_t fscript_exec_for(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
value_t v;
bool_t done = FALSE;
FSCRIPT_FUNC_CHECK(iter->args.size > 3, RET_FAIL);
FSCRIPT_FUNC_CHECK(fscript_eval_arg(fscript, iter, 0, &v) == RET_OK, RET_BAD_PARAMS);
fscript->loop_count++;
while (!done) {
break_if_fail(fscript_eval_arg(fscript, iter, 1, &v) == RET_OK);
if (!value_bool(&v)) {
break;
}
fscript_exec_loop_body(fscript, iter, 3, result, &done);
break_if_fail(fscript_eval_arg(fscript, iter, 2, &v) == RET_OK);
}
fscript->loop_count--;
return RET_OK;
}
static ret_t fscript_exec_for_in(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
value_t v;
char prop[32];
uint32_t i = 0;
uint32_t n = 0;
bool_t done = FALSE;
tk_object_t* obj = NULL;
value_t* var = iter->args.args;
int32_t index = value_id_index(var);
const char* name = value_id(var);
FSCRIPT_FUNC_CHECK(iter->args.size > 2, RET_FAIL);
FSCRIPT_FUNC_CHECK(fscript_eval_arg(fscript, iter, 1, &v) == RET_OK, RET_BAD_PARAMS);
obj = value_object(&v);
FSCRIPT_FUNC_CHECK(obj != NULL, RET_FAIL);
fscript->loop_count++;
n = tk_object_get_prop_int(obj, TK_OBJECT_PROP_SIZE, 0);
for (i = 0; ((i < n) && !done); i++) {
tk_snprintf(prop, sizeof(prop) - 1, "[%u]", i);
break_if_fail(tk_object_get_prop(obj, prop, &v) == RET_OK);
if (index >= 0) {
fscript_locals_set(fscript, var, &v);
} else {
fscript_set_var(fscript, name, &v);
}
fscript_exec_loop_body(fscript, iter, 2, result, &done);
}
fscript->loop_count--;
return RET_OK;
}
static ret_t fscript_exec_repeat_times(fscript_t* fscript, fscript_func_call_t* iter,
value_t* result) {
value_t v;
uint32_t i = 0;
uint32_t n = 0;
bool_t done = FALSE;
FSCRIPT_FUNC_CHECK(iter->args.size > 1, RET_FAIL);
FSCRIPT_FUNC_CHECK(fscript_eval_arg(fscript, iter, 0, &v) == RET_OK, RET_BAD_PARAMS);
n = value_int(&v);
fscript->loop_count++;
for (i = 0; i < n && !done; i++) {
fscript_exec_loop_body(fscript, iter, 1, result, &done);
}
fscript->loop_count--;
return RET_OK;
}
static ret_t fscript_exec_while(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
return fscript_exec_while_or_until(fscript, iter, result, TRUE);
}
static ret_t fscript_exec_until(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
return fscript_exec_while_or_until(fscript, iter, result, FALSE);
}
static ret_t fscript_exec_core_func(fscript_t* fscript, fscript_func_call_t* iter,
value_t* result) {
if (iter->func == func_if) {
return fscript_exec_if(fscript, iter, result);
} else if (iter->func == func_while) {
return fscript_exec_while(fscript, iter, result);
} else if (iter->func == func_until) {
return fscript_exec_until(fscript, iter, result);
} else if (iter->func == func_repeat) {
return fscript_exec_repeat(fscript, iter, result);
} else if (iter->func == func_for) {
return fscript_exec_for(fscript, iter, result);
} else if (iter->func == func_for_in) {
return fscript_exec_for_in(fscript, iter, result);
} else if (iter->func == func_repeat_times) {
return fscript_exec_repeat_times(fscript, iter, result);
} else if (iter->func == func_function_def) {
return RET_OK;
}
return RET_NOT_FOUND;
}
static ret_t fscript_exec_ext_func(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
value_t v;
uint32_t i = 0;
ret_t ret = RET_OK;
fscript_args_t args;
value_t args_values[5];
value_set_int(&v, 0);
if (iter->args.size <= ARRAY_SIZE(args_values)) {
memset(&args, 0x00, sizeof(args));
memset(&args_values, 0x00, sizeof(args_values));
args.capacity = ARRAY_SIZE(args_values);
args.args = args_values;
} else {
func_args_init(&args, iter->args.size);
}
args.size = iter->args.size;
return_value_if_fail((args.args != NULL || args.size == 0), RET_OOM);
for (i = 0; i < iter->args.size; i++) {
ret = fscript_eval_arg(fscript, iter, i, args.args + i);
if (fscript->breaked || fscript->continued || fscript->returned) {
value_deep_copy(result, args.args + i);
if (iter->args.size <= ARRAY_SIZE(args_values)) {
func_args_reset(&args);
} else {
func_args_deinit(&args);
}
return RET_OK;
}
}
value_set_int(result, 0);
fscript->curr = iter;
ret = iter->func(fscript, &args, result);
if (iter->args.size <= ARRAY_SIZE(args_values)) {
func_args_reset(&args);
} else {
func_args_deinit(&args);
}
return ret;
}
ret_t fscript_exec_func_default(fscript_t* fscript, fscript_func_call_t* iter, value_t* result) {
fscript->curr = iter;
result->type = VALUE_TYPE_INVALID;
if (iter->func == func_pending && iter->ctx != NULL) {
tk_object_t* obj = NULL;
void* ctx = iter->ctx;
char* name = (char*)(iter->ctx);
char* p = strchr(name, '.');
iter->ctx = NULL;
if (p != NULL) {
*p = '\0';
obj = fscript_locals_get_object(fscript, name);
name = p + 1;
}
obj = obj != NULL ? obj : fscript->obj;
fscript_func_call_init_func(iter, obj, fscript->funcs_def, name, tk_strlen(name));
if (iter->func == func_noop) {
log_warn("not found func %s\n", name);
}
TKMEM_FREE(ctx);
}
if (fscript_exec_core_func(fscript, iter, result) == RET_NOT_FOUND) {
return_value_if_fail(fscript_exec_ext_func(fscript, iter, result) == RET_OK, RET_FAIL);
}
return RET_OK;
}
ret_t fscript_exec(fscript_t* fscript, value_t* result) {
fscript_func_call_t* iter = NULL;
return_value_if_fail(fscript != NULL, RET_FAIL);
do {
fscript->rerun = FALSE;
fscript_hook_before_exec(fscript);
fscript_ensure_locals_by_symbols(fscript);
value_set_str(result, NULL);
iter = fscript->first;
while (iter != NULL) {
break_if_fail(iter->func != NULL);
value_reset(result);
break_if_fail(fscript_exec_func(fscript, NULL, iter, result) == RET_OK);
if (fscript->returned) {
fscript->returned = FALSE;
break;
}
iter = iter->next;
}
fscript_hook_after_exec(fscript);
fscript_locals_destroy(fscript);
} while (fscript->rerun);
return RET_OK;
}
static ret_t on_free_func_def(void* ctx, const void* data) {
named_value_t* iter = (named_value_t*)(data);
fscript_function_def_destroy(value_func_def(&(iter->value)));
return RET_OK;
}
ret_t fscript_clean(fscript_t* fscript) {
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
str_reset(&(fscript->str));
fscript_locals_destroy(fscript);
if (fscript->symbols) {
darray_destroy(fscript->symbols);
}
if (fscript->funcs_def != NULL) {
tk_object_foreach_prop(fscript->funcs_def, on_free_func_def, NULL);
TK_OBJECT_UNREF(fscript->funcs_def);
}
TK_OBJECT_UNREF(fscript->funcs_def);
TKMEM_FREE(fscript->error_message);
TKMEM_FREE(fscript->code_id);
if (fscript->first != NULL) {
fscript_func_call_destroy(fscript->first);
fscript->first = NULL;
}
return RET_OK;
}
static ret_t fscript_reset(fscript_t* fscript) {
return_value_if_fail(fscript != NULL, RET_FAIL);
fscript_hook_on_deinit(fscript);
fscript_clean(fscript);
memset(fscript, 0x00, sizeof(fscript_t));
return RET_OK;
}
ret_t fscript_deinit(fscript_t* fscript) {
return fscript_reset(fscript);
}
ret_t fscript_destroy(fscript_t* fscript) {
return_value_if_fail(fscript != NULL, RET_FAIL);
if (fscript->obj == NULL) {
return RET_FAIL;
}
fscript_deinit(fscript);
TKMEM_FREE(fscript);
return RET_OK;
}
static ret_t fscript_parser_init(fscript_parser_t* parser, tk_object_t* obj, const char* str,
fscript_parser_error_t* error) {
memset(parser, 0x00, sizeof(fscript_parser_t));
parser->obj = obj;
parser->str = str;
parser->cursor = str;
parser->error = error;
parser->symbols = darray_create(5, NULL, (tk_compare_t)tk_str_cmp);
str_init(&(parser->temp), FSCRIPT_STR_CAPACITY);
return RET_OK;
}
static ret_t fscript_parser_deinit(fscript_parser_t* parser) {
str_reset(&(parser->temp));
TKMEM_FREE(parser->code_id);
fscript_func_call_destroy(parser->first);
if (parser->symbols != NULL) {
darray_destroy(parser->symbols);
}
if (parser->funcs_def != NULL) {
tk_object_foreach_prop(parser->funcs_def, on_free_func_def, NULL);
}
TK_OBJECT_UNREF(parser->funcs_def);
return RET_OK;
}
static char fscript_parser_get_char(fscript_parser_t* parser) {
char c = '\0';
return_value_if_fail(parser != NULL, c);
if (parser->c) {
c = parser->c;
parser->c = '\0';
return c;
}
c = parser->cursor[0];
if (c) {
if (c == '\n') {
parser->row++;
parser->col = 0;
} else {
parser->col++;
}
parser->cursor++;
}
return c;
}
static ret_t fscript_parser_unget_char(fscript_parser_t* parser, char c) {
return_value_if_fail(parser->cursor > parser->str, RET_BAD_PARAMS);
parser->c = c;
return RET_OK;
}
static ret_t fscript_parser_set_error(fscript_parser_t* parser, const char* str) {
return_value_if_fail(parser != NULL && str != NULL, RET_BAD_PARAMS);
if (parser->error != NULL) {
parser->error->row = parser->row;
parser->error->col = parser->col;
parser->error->offset = parser->cursor - parser->str;
parser->error->message = tk_str_copy(parser->error->message, str);
parser->error->token = tk_str_copy(parser->error->token, parser->token.token);
}
log_warn("code: \"%s\"\n", parser->str);
log_warn("token: \"%s\"\n", parser->token.token);
log_warn("at line(%u) col (%u): %s\n", parser->row, parser->col, str);
return RET_FAIL;
}
static ret_t fscript_parser_skip_seperators(fscript_parser_t* parser) {
char c = '\0';
do {
c = fscript_parser_get_char(parser);
} while (tk_isspace(c));
fscript_parser_unget_char(parser, c);
return RET_OK;
}
#define STR_CODE_ID_START "code_id(\""
#define STR_CODE_ID_END "\")"
char* fscript_get_code_id(const char* str) {
const char* end = NULL;
const char* start = NULL;
return_value_if_fail(str != NULL, NULL);
start = strstr(str, STR_CODE_ID_START);
if (start != NULL) {
start += strlen(STR_CODE_ID_START);
end = strstr(start, STR_CODE_ID_END);
if (end != NULL) {
return tk_strndup(start, end - start);
}
}
return NULL;
}
static ret_t fscript_parser_skip_line_comment(fscript_parser_t* parser) {
char c = '\0';
str_t* str = &(parser->temp);
str_clear(str);
do {
c = fscript_parser_get_char(parser);
str_append_char(str, c);
} while (c != '\0' && c != '\r' && c != '\n');
if (str->size > sizeof(STR_CODE_ID_START)) {
char* code_id = fscript_get_code_id(str->str);
if (code_id != NULL) {
TKMEM_FREE(parser->code_id);
parser->code_id = code_id;
log_debug("code_id:%s\n", parser->code_id);
}
}
return RET_OK;
}
static ret_t fscript_parser_skip_block_comment(fscript_parser_t* parser) {
char c = '\0';
do {
c = fscript_parser_get_char(parser);
if (c == '*' && parser->cursor[0] == '/') {
c = fscript_parser_get_char(parser);
break;
}
} while (c != '\0');
return RET_OK;
}
static ret_t fscript_parser_skip_seperators_and_comments(fscript_parser_t* parser) {
char c = '\0';
while (TRUE) {
fscript_parser_skip_seperators(parser);
c = fscript_parser_get_char(parser);
if (c == '/') {
if (parser->cursor[0] == '/') {
c = fscript_parser_get_char(parser);
fscript_parser_skip_line_comment(parser);
} else if (parser->cursor[0] == '*') {
c = fscript_parser_get_char(parser);
fscript_parser_skip_block_comment(parser);
} else {
break;
}
} else {
break;
}
}
if (c) {
parser->cursor--;
if (parser->col > 0) {
parser->col--;
}
}
return RET_OK;
}
#define TOKEN_INIT(t, ttype, str) \
t->type = ttype; \
t->token = str->str; \
t->size = str->size;
static ret_t fscript_parser_parse_str(fscript_parser_t* parser, char quota) {
char c = '\0';
bool_t escape = FALSE;
str_t* str = &(parser->temp);
token_t* t = &(parser->token);
str_set(str, "");
do {
c = fscript_parser_get_char(parser);
if (escape) {
if (c == 'r') {
str_append_char(str, '\r');
} else if (c == 'n') {
str_append_char(str, '\n');
} else if (c == 't') {
str_append_char(str, '\t');
} else {
str_append_char(str, c);
}
escape = FALSE;
continue;
}
if (c == quota || c == '\0') {
break;
} else if (c == '\\') {
escape = TRUE;
continue;
}
str_append_char(str, c);
} while (TRUE);
TOKEN_INIT(t, TOKEN_STR, str);
if (c != '\0' && c != quota) {
fscript_parser_unget_char(parser, c);
}
return RET_OK;
}
static ret_t fscript_parser_get_non_ascii_char(fscript_parser_t* parser, str_t* str, uint8_t c,
uint32_t n) {
str_append_char(str, c);
while (n > 1) {
c = fscript_parser_get_char(parser);
str_append_char(str, c);
n--;
}
return RET_OK;
}
static ret_t fscript_parser_parse_id_or_number(fscript_parser_t* parser, token_type_t def_type) {
char c = '\0';
str_t* str = &(parser->temp);
token_t* t = &(parser->token);
c = fscript_parser_get_char(parser);
str_set(str, "");
if (c) {
int32_t n = tk_utf8_get_bytes_of_leading((uint8_t)c);
fscript_parser_get_non_ascii_char(parser, str, c, n);
}
do {
c = fscript_parser_get_char(parser);
if (tk_isxdigit(c) || tk_isdigit(c) || tk_isalpha(c) || c == '.' || c == '_' || c == '[' ||
c == ']' || c == '#') {
str_append_char(str, c);
} else if (tk_isspace(c)) {
break;
} else {
int32_t n = tk_utf8_get_bytes_of_leading((uint8_t)c);
if (n > 1) {
fscript_parser_get_non_ascii_char(parser, str, c, n);
} else {
break;
}
}
} while (TRUE);
if (tk_isspace(c)) {
fscript_parser_skip_seperators(parser);
c = fscript_parser_get_char(parser);
}
str_trim(str, " \t\r\n");
TOKEN_INIT(t, (c == '(' ? TOKEN_FUNC : def_type), str);
if (c != '\0') {
fscript_parser_unget_char(parser, c);
}
if (t->type == TOKEN_ID) {
if (tk_str_eq(t->token, "function")) {
t->type = TOKEN_FUNC_DEF;
} else if (tk_str_eq(t->token, "var")) {
t->type = TOKEN_VAR;
} else if (tk_str_eq(t->token, "return")) {
t->type = TOKEN_RETURN;
}
}
return RET_OK;
}
static ret_t fscript_parser_get_unary(fscript_parser_t* parser, char c, str_t* str) {
do {
fscript_parser_skip_seperators_and_comments(parser);
c = fscript_parser_get_char(parser);
if (c == str->str[0]) {
str_append_char(str, c);
} else {
fscript_parser_unget_char(parser, c);
break;
}
} while (TRUE);
return RET_OK;
}
static token_t* fscript_parser_get_token_ex(fscript_parser_t* parser, bool_t operator) {
char c = 0;
str_t* str = &(parser->temp);
token_t* t = &(parser->token);
if (t->valid) {
t->valid = FALSE;
return t;
}
fscript_parser_skip_seperators_and_comments(parser);
c = fscript_parser_get_char(parser);
str_set_with_len(str, &c, 1);
t->token = str->str;
t->size = 1;
switch (c) {
case '\0': {
t->type = TOKEN_EOF;
return NULL;
}
case '(': {
t->type = TOKEN_LPAREN;
return t;
}
case ')': {
t->type = TOKEN_RPAREN;
return t;
}
case '{': {
t->type = TOKEN_LBRACKET;
return t;
}
case '}': {
t->type = TOKEN_RBRACKET;
return t;
}
case ',': {
t->type = TOKEN_COMMA;
return t;
}
case ';': {
t->type = TOKEN_SEMICOLON;
return t;
}
case '?': {
t->type = TOKEN_QUESTION;
return t;
}
case ':': {
t->type = TOKEN_COLON;
return t;
}
case '*':
case '/':
case '%':
case '^':
case '#': {
t->type = TOKEN_FUNC;
return t;
}
case '>':
case '<':
case '=': {
c = fscript_parser_get_char(parser);
if (str->str[0] == c || c == '=') {
str_append_char(str, c);
} else {
fscript_parser_unget_char(parser, c);
}
t->type = TOKEN_FUNC;
t->size = str->size;
return t;
}
case '~':
case '!': {
c = fscript_parser_get_char(parser);
if (c == '=') {
str_append_char(str, c);
} else {
fscript_parser_unget_char(parser, c);
fscript_parser_get_unary(parser, c, str);
}
TOKEN_INIT(t, TOKEN_FUNC, str);
return t;
}
case '|':
case '&': {
c = fscript_parser_get_char(parser);
if (c == str->str[0]) {
str_append_char(str, c);
} else {
fscript_parser_unget_char(parser, c);
}
t->type = TOKEN_FUNC;
t->size = str->size;
return t;
}
case '\"':
case '\'': {
fscript_parser_parse_str(parser, c);
return t;
}
default: {
if (c == '+' || c == '-') {
fscript_parser_skip_seperators_and_comments(parser);
if (operator|| !tk_isdigit(parser->cursor[0])) {
fscript_parser_get_unary(parser, c, str);
TOKEN_INIT(t, TOKEN_FUNC, str);
} else {
fscript_parser_unget_char(parser, c);
fscript_parser_parse_id_or_number(parser, TOKEN_NUMBER);
}
} else if (tk_isdigit(c)) {
fscript_parser_unget_char(parser, c);
fscript_parser_parse_id_or_number(parser, TOKEN_NUMBER);
} else {
fscript_parser_unget_char(parser, c);
fscript_parser_parse_id_or_number(parser, TOKEN_ID);
}
return t;
}
}
}
static token_t* fscript_parser_get_token(fscript_parser_t* parser) {
return fscript_parser_get_token_ex(parser, FALSE);
}
static ret_t fscript_parser_expect_token(fscript_parser_t* parser, token_type_t type,
const char* msg) {
token_t* t = fscript_parser_get_token(parser);
if (t == NULL || t->type != type) {
return fscript_parser_set_error(parser, msg);
}
return RET_OK;
}
static ret_t fscript_parser_unget_token(fscript_parser_t* parser) {
if (parser->token.type != TOKEN_EOF) {
parser->token.valid = TRUE;
}
return RET_OK;
}
static ret_t token_to_value(fscript_parser_t* parser, token_t* t, value_t* v) {
if (t->type == TOKEN_NUMBER) {
char number[64];
tk_strncpy_s(number, sizeof(number), t->token, t->size);
if (strchr(number, '.') != NULL) {
value_set_double(v, tk_atof(number));
} else {
uint64_t vv = 0;
const char* str = number;
bool_t has_minus = FALSE;
if (*str == '-') {
has_minus = TRUE;
str++;
}
vv = tk_atoul(str);
if (vv < INT_MAX) {
if (has_minus) {
value_set_int32(v, -vv);
} else {
value_set_int32(v, vv);
}
} else if (vv < UINT32_MAX) {
if (has_minus) {
value_set_int64(v, -vv);
} else {
value_set_uint32(v, vv);
}
} else {
if (has_minus) {
value_set_int64(v, -vv);
} else {
value_set_uint64(v, vv);
}
}
}
} else if (t->type == TOKEN_STR) {
value_dup_str_with_len(v, t->token, t->size);
} else if (t->type == TOKEN_ID) {
if (t->token[0] == 't' && strncmp(t->token, "true", 4) == 0) {
value_set_bool(v, TRUE);
} else if (t->token[0] == 'f' && strncmp(t->token, "false", 5) == 0) {
value_set_bool(v, FALSE);
} else {
const char* name = NULL;
const char* p = NULL;
value_set_id(v, t->token, t->size);
name = value_id(v);
ENSURE(name);
p = strchr(name, '.');
if (p != NULL) {
char first_name[TK_NAME_LEN + 1];
tk_strncpy_s(first_name, sizeof(first_name), name, p - name);
value_id_suboffset(v) = p - name + 1;
value_id_index(v) = darray_find_index(parser->symbols, (void*)first_name);
} else {
value_id_suboffset(v) = 0;
value_id_index(v) = darray_find_index(parser->symbols, (void*)name);
}
}
} else {
return RET_FAIL;
}
return RET_OK;
}
ret_t fscript_eval(tk_object_t* obj, const char* script, value_t* result) {
value_t v;
ret_t ret = RET_OK;
fscript_t* fscript = fscript_create(obj, script);
return_value_if_fail(fscript != NULL, RET_BAD_PARAMS);
if (fscript_exec(fscript, &v) == RET_OK && result != NULL) {
value_deep_copy(result, &v);
}
value_reset(&v);
fscript_destroy(fscript);
return ret;
}
/*expr parser*/
static ret_t fexpr_parse_block(fscript_parser_t* parser, fscript_func_call_t* acall) {
value_t v;
fscript_func_call_t* statements = fscript_func_call_create(parser, "expr", 4);
return_value_if_fail(statements != NULL, RET_OOM);
if (fscript_parse_statements(parser, statements) == RET_OK) {
func_args_push(&(acall->args), value_set_func(&v, statements));
} else {
fscript_func_call_destroy(statements);
}
fscript_parser_expect_token(parser, TOKEN_RBRACKET, "expect \"}\"");
return RET_OK;
}
static ret_t fexpr_parse_function(fscript_parser_t* parser, value_t* result);
static ret_t fexpr_parse_if(fscript_parser_t* parser, fscript_func_call_t* acall) {
uint32_t i = 0;
token_t* t = NULL;
fexpr_parse_block(parser, acall);
t = fscript_parser_get_token(parser);
if (t != NULL && t->type == TOKEN_ID && tk_str_eq(t->token, "else")) {
t = fscript_parser_get_token(parser);
if (t != NULL && t->type == TOKEN_FUNC && tk_str_eq(t->token, "if")) {
value_t result;
fscript_func_call_t* elseif = NULL;
fscript_parser_unget_token(parser);
return_value_if_fail(fexpr_parse_function(parser, &result) == RET_OK, RET_FAIL);
elseif = value_func(&result);
for (i = 0; i < elseif->args.size; i++) {
func_args_push(&(acall->args), elseif->args.args + i);
}
elseif->args.size = 0;
fscript_func_call_destroy(elseif);
return RET_OK;
} else {
fscript_parser_unget_token(parser);
fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"");
return fexpr_parse_block(parser, acall);
}
} else {
fscript_parser_unget_token(parser);
return RET_OK;
}
}
static ret_t fexpr_parse_function(fscript_parser_t* parser, value_t* result) {
value_t v;
fscript_args_t* args = NULL;
token_t* t = fscript_parser_get_token(parser);
fscript_func_call_t* acall = NULL;
if (t->token[0] == '-' && t->size == 1) {
acall = fscript_func_call_create(parser, "minus", 5);
} else {
acall = fscript_func_call_create(parser, t->token, t->size);
}
value_set_func(result, acall);
return_value_if_fail(acall != NULL, RET_BAD_PARAMS);
args = &(acall->args);
return_value_if_fail(fscript_parser_expect_token(parser, TOKEN_LPAREN, "expect \"(\"") == RET_OK,
RET_FAIL);
do {
t = fscript_parser_get_token(parser);
if (t == NULL) {
return fscript_parser_set_error(parser, "expect \")\"");
}
value_set_int(&v, 0);
if (t->type == TOKEN_COMMA) {
v.type = VALUE_TYPE_INVALID;
func_args_push(args, &v);
continue;
} else if (t->type == TOKEN_RPAREN) {
if (args->size > 0) {
v.type = VALUE_TYPE_INVALID;
func_args_push(args, &v);
}
break;
} else {
fscript_parser_unget_token(parser);
}
return_value_if_fail(fexpr_parse(parser, &v) == RET_OK, RET_FAIL);
func_args_push(args, &v);
t = fscript_parser_get_token(parser);
if (t == NULL) {
return fscript_parser_set_error(parser, "expect \")\"");
} else if (t->type == TOKEN_RPAREN) {
break;
}
fscript_parser_unget_token(parser);
if (acall->func == func_for) {
fscript_parser_expect_token(parser, TOKEN_SEMICOLON, "expect \";\"");
} else {
fscript_parser_expect_token(parser, TOKEN_COMMA, "expect \",\"");
}
} while (TRUE);
if (acall->func == func_if && acall->args.size == 1) {
if (fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"") == RET_OK) {
fexpr_parse_if(parser, acall);
}
} else if ((acall->func == func_while || acall->func == func_until ||
acall->func == func_repeat_times) &&
acall->args.size == 1) {
if (fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"") == RET_OK) {
fexpr_parse_block(parser, acall);
}
} else if (acall->func == func_for && acall->args.size == 3) {
if (fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"") == RET_OK) {
fexpr_parse_block(parser, acall);
}
} else if (acall->func == func_for_in && acall->args.size == 2) {
if (fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"") == RET_OK) {
fexpr_parse_block(parser, acall);
}
} else if (acall->func == func_repeat && acall->args.size == 4) {
if (fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"") == RET_OK) {
fexpr_parse_block(parser, acall);
}
}
return RET_OK;
}
static ret_t fexpr_parse_term(fscript_parser_t* parser, value_t* result) {
ret_t ret = RET_OK;
token_t* t = fscript_parser_get_token(parser);
value_set_int(result, 0);
return_value_if_fail(t != NULL, RET_BAD_PARAMS);
if (t->type == TOKEN_NUMBER || t->type == TOKEN_ID || t->type == TOKEN_STR) {
if (t->type == TOKEN_ID && t->token[0] == '.') {
fscript_parser_set_error(parser, "var can't begin with '.'");
}
ret = token_to_value(parser, t, result);
} else if (t->type == TOKEN_FUNC) {
fscript_parser_unget_token(parser);
ret = fexpr_parse_function(parser, result);
} else if (t->type == TOKEN_RETURN) {
fscript_func_call_t* acall = fscript_func_call_create(parser, "return", 6);
return_value_if_fail(acall != NULL, RET_OOM);
value_set_func(result, acall);
t = fscript_parser_get_token(parser);
if (t != NULL && t->type != TOKEN_SEMICOLON && t->type != TOKEN_RBRACKET) {
value_t v;
value_set_int(&v, 0);
fscript_parser_unget_token(parser);
if (fexpr_parse(parser, &v) == RET_OK) {
func_args_push(&(acall->args), &v);
}
} else {
fscript_parser_unget_token(parser);
}
} else if (t->type == TOKEN_LPAREN) {
ret = fexpr_parse(parser, result);
return_value_if_fail(ret == RET_OK, ret);
ret = fscript_parser_expect_token(parser, TOKEN_RPAREN, "expect )");
} else {
fscript_parser_unget_token(parser);
}
return ret;
}
static ret_t fexpr_parse_unary(fscript_parser_t* parser, value_t* result) {
char c = '\0';
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
token_t* t = fscript_parser_get_token_ex(parser, FALSE);
if (t == NULL || t->type == TOKEN_EOF) {
return RET_OK;
}
c = t->token[0];
if (t->type == TOKEN_FUNC && (c == '!' || c == '~' || c == '-')) {
value_t v;
uint32_t i = 0;
bool_t valid = FALSE;
for (i = 0; i < t->size; i++) {
if (t->token[i] != c) {
return fscript_parser_set_error(parser, "unexpected token");
} else {
valid = !valid;
}
}
if (valid) {
acall = fscript_func_call_create(parser, &c, 1);
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
value_set_func(result, acall);
return_value_if_fail(fexpr_parse_term(parser, &v) == RET_OK, RET_FAIL);
func_args_push(args, &v);
} else {
return_value_if_fail(fexpr_parse_term(parser, result) == RET_OK, RET_FAIL);
}
} else {
fscript_parser_unget_token(parser);
return_value_if_fail(fexpr_parse_term(parser, result) == RET_OK, RET_FAIL);
}
return RET_OK;
}
static ret_t fsexpr_parse_product(fscript_parser_t* parser, value_t* result) {
value_t v;
token_t* t = NULL;
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
return_value_if_fail(fexpr_parse_unary(parser, result) == RET_OK, RET_FAIL);
while (TRUE) {
t = fscript_parser_get_token_ex(parser, TRUE);
if (t == NULL || t->type != TOKEN_FUNC) {
fscript_parser_unget_token(parser);
break;
}
if (t->token[0] == '*' || t->token[0] == '/' || t->token[0] == '%') {
acall = fscript_func_call_create(parser, t->token, t->size);
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
func_args_push(args, result);
value_set_func(result, acall);
v.type = VALUE_TYPE_INVALID;
fexpr_parse_unary(parser, &v);
if (v.type == VALUE_TYPE_INVALID) {
fscript_parser_set_error(parser, "expect an expression");
} else {
func_args_push(args, &v);
}
} else {
fscript_parser_unget_token(parser);
break;
}
}
return RET_OK;
}
static ret_t fexpr_parse_sum(fscript_parser_t* parser, value_t* result) {
value_t v;
token_t* t = NULL;
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
return_value_if_fail(fsexpr_parse_product(parser, result) == RET_OK, RET_FAIL);
while (TRUE) {
t = fscript_parser_get_token_ex(parser, TRUE);
if (t == NULL || t->type != TOKEN_FUNC) {
fscript_parser_unget_token(parser);
break;
}
if (t->token[0] == '+' || t->token[0] == '-') {
parser->token.valid = FALSE;
acall = fscript_func_call_create(parser, t->token, t->size);
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
func_args_push(args, result);
value_set_func(result, acall);
v.type = VALUE_TYPE_INVALID;
fsexpr_parse_product(parser, &v);
if (v.type == VALUE_TYPE_INVALID) {
fscript_parser_set_error(parser, "expect an expression");
} else {
func_args_push(args, &v);
}
} else {
fscript_parser_unget_token(parser);
break;
}
}
return RET_OK;
}
static ret_t fexpr_parse_compare(fscript_parser_t* parser, value_t* result) {
value_t v;
token_t* t = NULL;
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
value_set_int(result, 0);
return_value_if_fail(fexpr_parse_sum(parser, result) == RET_OK, RET_FAIL);
t = fscript_parser_get_token_ex(parser, TRUE);
if (t == NULL || t->type != TOKEN_FUNC || tk_str_eq(t->token, "=")) {
fscript_parser_unget_token(parser);
return RET_OK;
}
if (t->token[0] == '>' || t->token[0] == '<' || t->token[0] == '=' ||
(t->token[0] == '!' && t->token[1] == '=')) {
acall = fscript_func_call_create(parser, t->token, t->size);
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
func_args_push(args, result);
value_set_func(result, acall);
v.type = VALUE_TYPE_INVALID;
fexpr_parse_sum(parser, &v);
if (v.type == VALUE_TYPE_INVALID) {
fscript_parser_set_error(parser, "expect an expression");
} else {
func_args_push(args, &v);
}
} else {
fscript_parser_unget_token(parser);
}
return RET_OK;
}
static ret_t fexpr_parse_logic(fscript_parser_t* parser, value_t* result) {
value_t v;
token_t* t = NULL;
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
value_set_int(result, 0);
return_value_if_fail(fexpr_parse_compare(parser, result) == RET_OK, RET_FAIL);
while (TRUE) {
t = fscript_parser_get_token_ex(parser, TRUE);
if (t == NULL || t->type != TOKEN_FUNC || tk_str_eq(t->token, "=")) {
fscript_parser_unget_token(parser);
break;
}
if (t->token[0] == '|' || t->token[0] == '&' || t->token[0] == '^') {
acall = fscript_func_call_create(parser, t->token, t->size);
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
func_args_push(args, result);
value_set_func(result, acall);
v.type = VALUE_TYPE_INVALID;
fexpr_parse_compare(parser, &v);
if (v.type == VALUE_TYPE_INVALID) {
fscript_parser_set_error(parser, "expect an expression");
} else {
func_args_push(args, &v);
}
} else {
fscript_parser_unget_token(parser);
break;
}
}
return RET_OK;
}
static ret_t fexpr_parse_question(fscript_parser_t* parser, value_t* result) {
value_t v;
ret_t ret = RET_OK;
token_t* t = NULL;
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
value_set_str(&v, NULL);
if (fexpr_parse_logic(parser, result) == RET_OK) {
t = fscript_parser_get_token(parser);
if (t && t->type == TOKEN_QUESTION) {
acall = fscript_func_call_create(parser, "if", 2);
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
func_args_push(args, result);
value_set_func(result, acall);
value_reset(&v);
return_value_if_fail(fexpr_parse_logic(parser, &v) == RET_OK, RET_FAIL);
func_args_push(args, &v);
return_value_if_fail(fscript_parser_expect_token(parser, TOKEN_COLON, "expect :") == RET_OK,
RET_FAIL);
return_value_if_fail(fexpr_parse_logic(parser, &v) == RET_OK, RET_FAIL);
func_args_push(args, &v);
} else {
fscript_parser_unget_token(parser);
}
} else {
ret = RET_FAIL;
}
return ret;
}
static ret_t fexpr_parse(fscript_parser_t* parser, value_t* result) {
value_t v;
token_t* t = NULL;
bool_t is_local = FALSE;
fscript_args_t* args = NULL;
fscript_func_call_t* acall = NULL;
value_set_int(result, 0);
t = fscript_parser_get_token_ex(parser, TRUE);
if (t == NULL || t->type == TOKEN_RBRACKET || t->type == TOKEN_SEMICOLON) {
value_reset(result);
fscript_parser_unget_token(parser);
return RET_OK;
}
if (t->type == TOKEN_VAR) {
is_local = TRUE;
} else {
fscript_parser_unget_token(parser);
}
return_value_if_fail(fexpr_parse_question(parser, result) == RET_OK, RET_FAIL);
t = fscript_parser_get_token_ex(parser, TRUE);
if (t != NULL && tk_str_eq(t->token, "=")) {
const char* name = is_local ? "set_local" : "=";
acall = fscript_func_call_create(parser, name, strlen(name));
return_value_if_fail(acall != NULL, RET_OOM);
args = &(acall->args);
func_args_push(args, result);
value_set_func(result, acall);
v.type = VALUE_TYPE_INVALID;
fexpr_parse_question(parser, &v);
if (v.type == VALUE_TYPE_INVALID) {
fscript_parser_set_error(parser, "expect an expression");
} else {
func_args_push(args, &v);
}
if (is_local) {
darray_push_unique(parser->symbols, (void*)value_id(args->args));
}
} else {
fscript_parser_unget_token(parser);
}
return RET_OK;
}
static fscript_t* fscript_init_with_parser(fscript_t* fscript, fscript_parser_t* parser) {
fscript = fscript != NULL ? fscript : TKMEM_ZALLOC(fscript_t);
return_value_if_fail(fscript != NULL, NULL);
fscript->str = parser->temp;
fscript->obj = parser->obj;
fscript->first = parser->first;
fscript->funcs_def = parser->funcs_def;
fscript->code_id = parser->code_id;
fscript->symbols = parser->symbols;
fscript->lines = parser->row + 1;
fscript_hook_on_init(fscript, parser->str);
parser->obj = NULL;
parser->first = NULL;
parser->temp.str = NULL;
parser->funcs_def = NULL;
parser->code_id = NULL;
parser->symbols = NULL;
return fscript;
}
static ret_t func_function(fscript_t* fscript, fscript_args_t* args, value_t* result) {
ret_t ret = RET_OK;
darray_t* saved_locals = fscript->locals;
fscript_function_def_t* func_def = (fscript_function_def_t*)(fscript->curr->ctx);
fscript_func_call_t* func = func_def->body;
func->func = func_noop;
fscript->locals = NULL;
if (func_def->params.size > 0 && args->size > 0) {
uint32_t i = 0;
uint32_t n = tk_min(func_def->params.size, args->size);
for (i = 0; i < n; i++) {
const value_t* value = args->args + i;
const char* name = (const char*)(func_def->params.elms[i]);
fscript_locals_create(fscript, name, value);
}
}
ret = fscript_exec_func(fscript, func_def->name, func, result);
fscript_locals_destroy(fscript);
fscript->locals = saved_locals;
fscript->returned = FALSE;
return ret;
}
static ret_t fscript_parse_function_def(fscript_parser_t* parser, fscript_func_call_t* acall) {
value_t v;
char func_name[TK_NAME_LEN + 1];
fscript_function_def_t* func_def = NULL;
fscript_func_call_t* statements = NULL;
token_t* t = fscript_parser_get_token(parser);
darray_t* saved_symbols = parser->symbols;
if (t->type != TOKEN_FUNC) {
return fscript_parser_set_error(parser, "expect function name\n");
}
tk_strncpy(func_name, t->token, TK_NAME_LEN);
fscript_parser_expect_token(parser, TOKEN_LPAREN, "expect \"(\"");
if (parser->funcs_def == NULL) {
parser->funcs_def = object_default_create();
}
if (tk_object_get_prop(parser->funcs_def, func_name, &v) == RET_OK) {
return fscript_parser_set_error(parser, "duplicate function\n");
}
statements = fscript_func_call_create(parser, "func", 4);
return_value_if_fail(statements != NULL, RET_OOM);
func_def = fscript_function_def_create(func_name, statements);
return_value_if_fail(func_def != NULL, RET_OOM);
value_set_func_def(&v, func_def);
tk_object_set_prop(parser->funcs_def, func_name, &v);
parser->symbols = darray_create(5, NULL, (tk_compare_t)tk_str_cmp);
while (TRUE) {
t = fscript_parser_get_token(parser);
if (t == NULL || t->type == TOKEN_EOF || t->type == TOKEN_RPAREN) {
fscript_parser_unget_token(parser);
break;
}
if (t->type == TOKEN_ID) {
fscript_function_def_add_param(func_def, t->token);
darray_push_unique(parser->symbols,
(void*)darray_get(&(func_def->params), func_def->params.size - 1));
} else if (t->type == TOKEN_COMMA) {
} else {
fscript_parser_unget_token(parser);
break;
}
}
fscript_parser_expect_token(parser, TOKEN_RPAREN, "expect \")\"");
fscript_parser_expect_token(parser, TOKEN_LBRACKET, "expect \"{\"");
fscript_parse_statements(parser, statements);
fscript_parser_expect_token(parser, TOKEN_RBRACKET, "expect \"}\"");
darray_destroy(parser->symbols);
parser->symbols = saved_symbols;
return RET_OK;
}
static ret_t fscript_parse_statements(fscript_parser_t* parser, fscript_func_call_t* acall) {
value_t v;
ret_t ret = RET_OK;
fscript_args_t* args = NULL;
return_value_if_fail(parser != NULL && acall != NULL, RET_BAD_PARAMS);
args = &(acall->args);
do {
token_t* t = NULL;
value_set_int(&v, 0);
ret = fexpr_parse(parser, &v);
if (ret == RET_OK) {
if (v.type != VALUE_TYPE_INVALID) {
func_args_push(args, &v);
}
t = fscript_parser_get_token(parser);
if (t == NULL) {
break;
}
if (t->type == TOKEN_FUNC || t->type == TOKEN_ID || t->type == TOKEN_NUMBER ||
t->type == TOKEN_STR || t->type == TOKEN_VAR || t->type == TOKEN_RETURN) {
fscript_parser_unget_token(parser);
} else if (t->type == TOKEN_RBRACKET || t->type == TOKEN_FUNC_DEF) {
fscript_parser_unget_token(parser);
break;
} else if (t->type != TOKEN_COMMA && t->type != TOKEN_SEMICOLON) {
return fscript_parser_set_error(parser, "unexpected token\n");
}
} else {
if (v.type == VALUE_TYPE_FSCRIPT_FUNC) {
fscript_func_call_destroy(value_func(&v));
} else {
value_reset(&v);
}
break;
}
} while (parser->token.type != TOKEN_EOF);
return RET_OK;
}
static ret_t fscript_parse_all(fscript_parser_t* parser, fscript_func_call_t* acall) {
ret_t ret = RET_OK;
while (ret == RET_OK) {
token_t* t = fscript_parser_get_token(parser);
if (t && t->type == TOKEN_FUNC_DEF) {
ret = fscript_parse_function_def(parser, acall);
} else if (t == NULL || t->type == TOKEN_EOF) {
break;
} else if (t->type == TOKEN_RBRACKET) {
fscript_parser_set_error(parser, "unexpected token");
break;
} else {
fscript_parser_unget_token(parser);
ret = fscript_parse_statements(parser, acall);
}
}
return ret;
}
fscript_parser_error_t* fscript_parser_error_init(fscript_parser_error_t* error) {
return_value_if_fail(error != NULL, NULL);
memset(error, 0x00, sizeof(fscript_parser_error_t));
return error;
}
ret_t fscript_parser_error_deinit(fscript_parser_error_t* error) {
return_value_if_fail(error != NULL, RET_BAD_PARAMS);
TKMEM_FREE(error->token);
TKMEM_FREE(error->message);
return RET_OK;
}
ret_t fscript_syntax_check(tk_object_t* obj, const char* script, fscript_parser_error_t* error) {
ret_t ret = RET_OK;
fscript_parser_t parser;
return_value_if_fail(obj != NULL && script != NULL && error != NULL, RET_BAD_PARAMS);
fscript_parser_error_init(error);
fscript_parser_init(&parser, obj, script, error);
parser.first = fscript_func_call_create(&parser, "expr", 4);
ret = fscript_parse_all(&parser, parser.first);
fscript_parser_deinit(&parser);
return ret;
}
static fscript_t* fscript_load(fscript_t* fscript, tk_object_t* obj, const char* script,
const char* first_call_name, bool_t keep_func_name) {
ret_t ret = RET_OK;
fscript_parser_t parser;
fscript_parser_error_t error;
return_value_if_fail(script != NULL, NULL);
fscript_parser_error_init(&error);
fscript_parser_init(&parser, obj, script, &error);
parser.keep_func_name = keep_func_name;
parser.first = fscript_func_call_create(&parser, first_call_name, strlen(first_call_name));
ret = fscript_parse_all(&parser, parser.first);
if (ret == RET_OK) {
fscript = fscript_init_with_parser(fscript, &parser);
fscript_parser_deinit(&parser);
} else {
log_warn("parser error:%s\n", script);
fscript_parser_deinit(&parser);
}
fscript_parser_error_deinit(&error);
return fscript;
}
ret_t fscript_reload(fscript_t* fscript, const char* script) {
tk_object_t* obj = NULL;
return_value_if_fail(fscript != NULL && fscript->obj != NULL && script != NULL, RET_BAD_PARAMS);
obj = fscript->obj;
fscript_reset(fscript);
return fscript_load(fscript, obj, script, "expr", FALSE) != NULL ? RET_OK : RET_FAIL;
}
fscript_t* fscript_init(fscript_t* fscript, tk_object_t* obj, const char* script,
const char* first_call_name, bool_t keep_func_name) {
return fscript_load(fscript, obj, script, first_call_name, keep_func_name);
}
fscript_t* fscript_create_ex(tk_object_t* obj, const char* script, bool_t keep_func_name) {
return fscript_load(NULL, obj, script, "expr", keep_func_name);
}
fscript_t* fscript_create(tk_object_t* obj, const char* script) {
return fscript_create_ex(obj, script, FALSE);
}
/*functions*/
static ret_t func_get_last_error(fscript_t* fscript, fscript_args_t* args, value_t* result) {
if (fscript->error_code != RET_OK) {
tk_object_t* obj = object_default_create();
return_value_if_fail(obj != NULL, RET_OOM);
tk_object_set_prop_int(obj, "col", fscript->error_col);
tk_object_set_prop_int(obj, "line", fscript->error_row);
tk_object_set_prop_int(obj, "code", fscript->error_code);
tk_object_set_prop_str(obj, "message", fscript->error_message);
value_set_object(result, obj);
result->free_handle = TRUE;
} else {
value_set_int(result, 0);
value_reset(result);
}
return RET_OK;
}
static ret_t func_has_error(fscript_t* fscript, fscript_args_t* args, value_t* result) {
value_set_bool(result, fscript->error_code != RET_OK);
return RET_OK;
}
static ret_t func_clear_error(fscript_t* fscript, fscript_args_t* args, value_t* result) {
fscript_set_error(fscript, RET_OK, NULL, NULL);
return RET_OK;
}
static ret_t func_sum(fscript_t* fscript, fscript_args_t* args, value_t* result) {
double v = 0;
uint32_t i = 0;
bool_t has_str = FALSE;
bool_t has_bin = FALSE;
bool_t has_float = FALSE;
FSCRIPT_FUNC_CHECK(args->size > 0, RET_BAD_PARAMS);
for (i = 0; i < args->size; i++) {
int type = args->args[i].type;
if (type == VALUE_TYPE_STRING) {
has_str = TRUE;
} else if (type == VALUE_TYPE_BINARY) {
has_bin = TRUE;
} else if (type == VALUE_TYPE_FLOAT || type == VALUE_TYPE_DOUBLE ||
type == VALUE_TYPE_FLOAT32) {
has_float = TRUE;
}
}
if (has_str) {
str_t str;
char buff[64];
str_init(&str, FSCRIPT_STR_CAPACITY);
for (i = 0; i < args->size; i++) {
str_append(&str, value_str_ex(args->args + i, buff, sizeof(buff) - 1));
}
value_dup_str(result, str.str);
str_reset(&str);
} else if (has_bin) {
wbuffer_t wb;
char buff[64];
wbuffer_init_extendable(&wb);
for (i = 0; i < args->size; i++) {
value_t* iter = args->args + i;
if (iter->type == VALUE_TYPE_BINARY) {
binary_data_t* b = value_binary_data(iter);
wbuffer_write_binary(&wb, b->data, b->size);
} else {
wbuffer_write_string(&wb, value_str_ex(iter, buff, sizeof(buff) - 1));
}
}
value_set_binary_data(result, wb.data, wb.cursor);
result->free_handle = TRUE;
} else {
for (i = 0; i < args->size; i++) {
v += value_double(args->args + i);
}
if (has_float) {
value_set_double(result, v);
} else {
value_set_int(result, (int)v);
}
}
return RET_OK;
}
static ret_t func_int(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int(result, value_int(args->args));
return RET_OK;
}
static ret_t func_i8(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int8(result, value_int8(args->args));
return RET_OK;
}
static ret_t func_i16(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int16(result, value_int16(args->args));
return RET_OK;
}
static ret_t func_i32(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int(result, value_int(args->args));
return RET_OK;
}
static ret_t func_i64(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int64(result, value_int64(args->args));
return RET_OK;
}
static ret_t func_u8(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_uint8(result, value_uint8(args->args));
return RET_OK;
}
static ret_t func_u16(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_uint16(result, value_uint16(args->args));
return RET_OK;
}
static ret_t func_u32(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_uint32(result, value_uint32(args->args));
return RET_OK;
}
static ret_t func_u64(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_uint64(result, value_uint64(args->args));
return RET_OK;
}
static ret_t func_f32(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_float32(result, value_float32(args->args));
return RET_OK;
}
static ret_t func_double(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_double(result, value_double(args->args));
return RET_OK;
}
static ret_t func_binary(fscript_t* fscript, fscript_args_t* args, value_t* result) {
void* p = NULL;
uint32_t size = 0;
/*基本类型默认拷贝*/
bool_t clone = TRUE;
value_t* v = args->args;
FSCRIPT_FUNC_CHECK(args->size >= 1, RET_BAD_PARAMS);
switch (v->type) {
case VALUE_TYPE_BOOL: {
size = sizeof(int8_t);
p = &(v->value.b);
break;
}
case VALUE_TYPE_INT8: {
size = sizeof(int8_t);
p = &(v->value.i8);
break;
}
case VALUE_TYPE_UINT8: {
size = sizeof(uint8_t);
p = &(v->value.u8);
break;
}
case VALUE_TYPE_INT16: {
size = sizeof(int16_t);
p = &(v->value.i16);
break;
}
case VALUE_TYPE_UINT16: {
size = sizeof(uint16_t);
p = &(v->value.u16);
break;
}
case VALUE_TYPE_INT32: {
size = sizeof(int32_t);
p = &(v->value.i32);
break;
}
case VALUE_TYPE_UINT32: {
size = sizeof(uint32_t);
p = &(v->value.u32);
break;
}
case VALUE_TYPE_INT64: {
size = sizeof(int64_t);
p = &(v->value.i64);
break;
}
case VALUE_TYPE_UINT64: {
size = sizeof(uint64_t);
p = &(v->value.u64);
break;
}
case VALUE_TYPE_FLOAT: {
size = sizeof(float_t);
p = &(v->value.f32);
break;
}
case VALUE_TYPE_FLOAT32: {
size = sizeof(float);
p = &(v->value.f32);
break;
}
case VALUE_TYPE_DOUBLE: {
size = sizeof(double);
p = &(v->value.f64);
break;
}
case VALUE_TYPE_STRING: {
p = (void*)value_str(v);
size = tk_strlen(value_str(v));
clone = FALSE;
break;
}
case VALUE_TYPE_WSTRING: {
p = (void*)value_wstr(v);
size = wcslen(value_wstr(v)) * sizeof(wchar_t);
clone = FALSE;
break;
}
case VALUE_TYPE_POINTER: {
p = value_pointer(v);
size = args->size > 1 ? value_uint32(args->args + 1) : 0;
clone = FALSE;
break;
}
case VALUE_TYPE_BINARY: {
p = v->value.binary_data.data;
size = v->value.binary_data.size;
clone = FALSE;
break;
}
case VALUE_TYPE_SIZED_STRING: {
p = v->value.sized_str.str;
size = v->value.sized_str.size;
clone = FALSE;
break;
}
default: {
log_debug("not supported type\n");
break;
}
}
if (p == NULL || size == 0) {
value_set_binary_data(result, p, size);
return RET_OK;
}
/*参数1指定长度*/
if (args->size > 1) {
uint32_t esize = value_uint32(args->args + 1);
if (esize <= size) {
size = esize;
} else {
log_debug("size is too large, use default\n");
}
}
/*参数2要求复制*/
if (args->size > 2 && value_bool(args->args + 2)) {
clone = TRUE;
}
if (clone) {
p = tk_memdup(p, size);
value_set_binary_data(result, p, size);
result->free_handle = TRUE;
} else {
value_set_binary_data(result, p, size);
}
return RET_OK;
}
static ret_t func_str(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
value_t* v = args->args;
bool_t force_pointer_as_str = args->size == 2 && value_bool(args->args + 1);
FSCRIPT_FUNC_CHECK(args->size >= 1, RET_BAD_PARAMS);
if (force_pointer_as_str) {
if (v->type == VALUE_TYPE_POINTER) {
value_set_str(result, (const char*)value_pointer(v));
return RET_OK;
} else if (v->type == VALUE_TYPE_BINARY) {
value_set_str(result, (const char*)(v->value.binary_data.data));
return RET_OK;
}
}
str_from_value(str, args->args);
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_one_of(fscript_t* fscript, fscript_args_t* args, value_t* result) {
char sep = ';';
int32_t index = 0;
const char* strs = NULL;
const char* start = NULL;
value_set_str(result, "");
FSCRIPT_FUNC_CHECK(args->size >= 2, RET_BAD_PARAMS);
FSCRIPT_FUNC_CHECK(args->args[0].type == VALUE_TYPE_STRING, RET_BAD_PARAMS);
strs = value_str(args->args);
FSCRIPT_FUNC_CHECK(strs != NULL, RET_BAD_PARAMS);
if (args->size > 2 && args->args[2].type == VALUE_TYPE_STRING) {
const char* p = value_str(args->args + 2);
if (p != NULL) {
sep = *p;
}
}
start = strs;
index = value_int(args->args + 1);
while (index > 0) {
while (*start && *start != sep) {
start++;
}
if (*start == '\0') {
break;
}
index--;
start++;
}
if (start != NULL) {
const char* end = strchr(start, sep);
if (end != NULL) {
value_dup_str_with_len(result, start, end - start);
} else {
value_dup_str(result, start);
}
}
return RET_OK;
}
static ret_t func_join(fscript_t* fscript, fscript_args_t* args, value_t* result) {
uint32_t i = 0;
char buff[64];
str_t* str = &(fscript->str);
value_set_bool(result, FALSE);
FSCRIPT_FUNC_CHECK(args->size > 1, RET_BAD_PARAMS);
str_set(str, "");
value_set_bool(result, TRUE);
for (i = 1; i < args->size; i++) {
if (i > 1) {
str_append(str, value_str_ex(args->args, buff, sizeof(buff)));
}
str_append(str, value_str_ex(args->args + i, buff, sizeof(buff)));
}
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_set_local(fscript_t* fscript, fscript_args_t* args, value_t* result) {
const char* name = NULL;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
name = value_id(args->args);
FSCRIPT_FUNC_CHECK(name != NULL, RET_BAD_PARAMS);
value_set_bool(result, fscript_locals_create(fscript, name, args->args + 1) == RET_OK);
return RET_OK;
}
static ret_t func_get(fscript_t* fscript, fscript_args_t* args, value_t* result) {
ret_t ret = RET_OK;
value_t* v = args->args;
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
return_value_if_fail(v->type == VALUE_TYPE_ID || v->type == VALUE_TYPE_STRING, RET_BAD_PARAMS);
if (v->type == VALUE_TYPE_STRING) {
const char* name = value_str(v);
ret = fscript_get_var(fscript, name, result);
} else {
if (value_id_index(v) >= 0) {
ret = fscript_locals_get(fscript, v, result);
} else {
const char* name = value_id(v);
ret = fscript_get_var(fscript, name, result);
}
}
if (ret != RET_OK) {
result->type = VALUE_TYPE_INVALID;
}
return RET_OK;
}
static ret_t func_set(fscript_t* fscript, fscript_args_t* args, value_t* result) {
int32_t index = 0;
value_t* v = args->args;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
return_value_if_fail(v->type == VALUE_TYPE_ID || v->type == VALUE_TYPE_STRING, RET_BAD_PARAMS);
if (v->type == VALUE_TYPE_STRING) {
const char* name = value_str(v);
value_set_bool(result, fscript_set_var(fscript, name, args->args + 1) == RET_OK);
} else {
index = value_id_index(v);
if (index >= 0) {
value_set_bool(result, fscript_locals_set(fscript, v, args->args + 1) == RET_OK);
} else {
const char* name = value_id(v);
value_set_bool(result, fscript_set_var(fscript, name, args->args + 1) == RET_OK);
}
}
return RET_OK;
}
static ret_t func_unset(fscript_t* fscript, fscript_args_t* args, value_t* result) {
int32_t index = 0;
value_t* v = args->args;
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
return_value_if_fail(v->type == VALUE_TYPE_ID || v->type == VALUE_TYPE_STRING, RET_BAD_PARAMS);
if (v->type == VALUE_TYPE_STRING) {
const char* name = value_str(v);
tk_object_remove_prop(fscript->obj, name);
} else {
index = value_id_index(v);
if (index >= 0) {
fscript_locals_remove(fscript, index);
} else {
const char* name = value_id(v);
tk_object_remove_prop(fscript->obj, name);
}
}
value_set_bool(result, TRUE);
return RET_OK;
}
static ret_t func_expr(fscript_t* fscript, fscript_args_t* args, value_t* result) {
if (args->size >= 1) {
value_deep_copy(result, args->args + args->size - 1);
} else {
result->type = VALUE_TYPE_INVALID;
}
return RET_OK;
}
static ret_t func_print(fscript_t* fscript, fscript_args_t* args, value_t* result) {
if (fscript->print != NULL) {
return fscript->print(fscript, args, result);
} else {
uint32_t i = 0;
char buff[64] = {0};
value_set_bool(result, TRUE);
for (i = 0; i < args->size; i++) {
log_info("%s ", value_str_ex(args->args + i, buff, sizeof(buff) - 1));
}
log_info("\n");
(void)buff;
}
return RET_OK;
}
static ret_t func_iformat(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
const char* format = NULL;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
format = value_str(args->args);
FSCRIPT_FUNC_CHECK(format != NULL, RET_BAD_PARAMS);
tk_snprintf(str->str, str->capacity > FSCRIPT_STR_CAPACITY ? FSCRIPT_STR_CAPACITY - 1 : str->capacity - 1, format, value_int(args->args + 1));
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_fformat(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
const char* format = NULL;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
format = value_str(args->args);
FSCRIPT_FUNC_CHECK(format != NULL, RET_BAD_PARAMS);
tk_snprintf(str->str, str->capacity - 1, format, value_float(args->args + 1));
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_and(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
value_set_bool(result, value_bool(args->args) && value_bool(args->args + 1));
return RET_OK;
}
static ret_t func_or(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
value_set_bool(result, value_bool(args->args) || value_bool(args->args + 1));
return RET_OK;
}
static ret_t func_not(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_bool(result, !value_bool(args->args));
return RET_OK;
}
static ret_t func_minus(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
if (args->args[0].type == VALUE_TYPE_INT32) {
value_set_int(result, -value_int(args->args));
} else {
value_set_double(result, -value_double(args->args));
}
return RET_OK;
}
static ret_t func_div(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
value_set_double(result, value_double(args->args) / value_double(args->args + 1));
return RET_OK;
}
static ret_t func_mod(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
value_set_int(result, value_int(args->args) % value_int(args->args + 1));
return RET_OK;
}
static ret_t func_mul(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
value_set_double(result, value_double(args->args) * value_double(args->args + 1));
return RET_OK;
}
static ret_t func_sub(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size >= 1, RET_BAD_PARAMS);
if (args->size == 1) {
func_minus(fscript, args, result);
} else {
if (args->args->type == VALUE_TYPE_INT32 && args->args[1].type == VALUE_TYPE_INT32) {
value_set_int(result, value_int(args->args) - value_int(args->args + 1));
} else {
value_set_double(result, value_double(args->args) - value_double(args->args + 1));
}
}
return RET_OK;
}
static ret_t func_random(fscript_t* fscript, fscript_args_t* args, value_t* result) {
long v = random();
if (args->size == 2) {
int32_t min = value_int(args->args);
int32_t max = value_int(args->args + 1);
if (min < max) {
v = min + v % (max - min);
}
}
value_set_int(result, v);
return RET_OK;
}
static ret_t func_le(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
if (args->args[0].type == VALUE_TYPE_STRING && args->args[1].type == VALUE_TYPE_STRING) {
value_set_bool(result, tk_str_cmp(value_str(args->args), value_str(args->args + 1)) <= 0);
} else {
value_set_bool(result, value_double(args->args) <= value_double(args->args + 1));
}
return RET_OK;
}
static ret_t func_less(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
if (args->args[0].type == VALUE_TYPE_STRING && args->args[1].type == VALUE_TYPE_STRING) {
value_set_bool(result, tk_str_cmp(value_str(args->args), value_str(args->args + 1)) < 0);
} else {
value_set_bool(result, value_double(args->args) < value_double(args->args + 1));
}
return RET_OK;
}
static ret_t func_ge(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
if (args->args[0].type == VALUE_TYPE_STRING && args->args[1].type == VALUE_TYPE_STRING) {
value_set_bool(result, tk_str_cmp(value_str(args->args), value_str(args->args + 1)) >= 0);
} else {
value_set_bool(result, value_double(args->args) >= value_double(args->args + 1));
}
return RET_OK;
}
static ret_t func_great(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
if (args->args[0].type == VALUE_TYPE_STRING && args->args[1].type == VALUE_TYPE_STRING) {
value_set_bool(result, tk_str_cmp(value_str(args->args), value_str(args->args + 1)) > 0);
} else {
value_set_bool(result, value_double(args->args) > value_double(args->args + 1));
}
return RET_OK;
}
static ret_t func_eq(fscript_t* fscript, fscript_args_t* args, value_t* result) {
value_t* v1 = NULL;
value_t* v2 = NULL;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
v1 = args->args;
v2 = args->args + 1;
if (v1->type == VALUE_TYPE_STRING && v2->type == VALUE_TYPE_STRING) {
value_set_bool(result, tk_str_eq(value_str(v1), value_str(v2)));
} else if (v1->type == VALUE_TYPE_POINTER && v2->type == VALUE_TYPE_POINTER) {
value_set_bool(result, value_pointer(v1) == value_pointer(v2));
} else if (v1->type == VALUE_TYPE_OBJECT && v2->type == VALUE_TYPE_OBJECT) {
value_set_bool(result, value_object(v1) == value_object(v2));
} else if (v1->type == VALUE_TYPE_BINARY && v2->type == VALUE_TYPE_BINARY) {
binary_data_t* bin1 = value_binary_data(v1);
binary_data_t* bin2 = value_binary_data(v2);
if (bin1->size == bin2->size) {
value_set_bool(result, tk_str_cmp((const char*)bin1->data, (const char*)bin2->data) == 0);
} else {
value_set_bool(result, FALSE);
}
} else if (v1->type == VALUE_TYPE_INT64 || v2->type == VALUE_TYPE_INT64) {
value_set_bool(result, value_int64(v1) == value_int64(v2));
} else if (v1->type == VALUE_TYPE_UINT64 || v2->type == VALUE_TYPE_UINT64) {
value_set_bool(result, value_uint64(v1) == value_uint64(v2));
} else if (v1->type != v2->type && !(value_is_digit(v1) && value_is_digit(v2))) {
value_set_bool(result, FALSE);
} else {
value_set_bool(result, tk_fequal(value_double(v1), value_double(v2)));
}
return RET_OK;
}
static ret_t func_not_eq(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
func_eq(fscript, args, result);
value_set_bool(result, !value_bool(result));
return RET_OK;
}
static ret_t func_assert(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size >= 1, RET_BAD_PARAMS);
if (!value_bool(args->args)) {
fscript_set_error(fscript, RET_FAIL, __FUNCTION__,
args->size > 1 ? value_str(args->args + 1) : "unkown");
if (args->size > 1 && value_bool(args->args + 1)) {
assert(0);
} else {
log_debug("assert failed at: (%d %d)\n", (int)(fscript->curr->row),
(int)(fscript->curr->col));
}
}
return RET_OK;
}
static ret_t func_min(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
if (value_double(args->args) < value_double(args->args + 1)) {
value_deep_copy(result, args->args);
} else {
value_deep_copy(result, args->args + 1);
}
return RET_OK;
}
static ret_t func_max(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
if (value_double(args->args) > value_double(args->args + 1)) {
value_deep_copy(result, args->args);
} else {
value_deep_copy(result, args->args + 1);
}
return RET_OK;
}
static ret_t func_clamp(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 3, RET_BAD_PARAMS);
if (value_double(args->args) < value_double(args->args + 1)) {
value_deep_copy(result, args->args + 1);
} else if (value_double(args->args) > value_double(args->args + 2)) {
value_deep_copy(result, args->args + 2);
} else {
value_deep_copy(result, args->args);
}
return RET_OK;
}
static ret_t func_round(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int64(result, round(value_double(args->args)));
return RET_OK;
}
static ret_t func_floor(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int64(result, floor(value_double(args->args)));
return RET_OK;
}
static ret_t func_ceil(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
value_set_int64(result, ceil(value_double(args->args)));
return RET_OK;
}
static ret_t func_abs(fscript_t* fscript, fscript_args_t* args, value_t* result) {
value_t* v = NULL;
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
v = args->args;
switch (v->type) {
case VALUE_TYPE_INT8: {
value_set_int8(result, tk_abs(value_int8(v)));
break;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(result, value_uint8(v));
break;
}
case VALUE_TYPE_INT16: {
value_set_int16(result, tk_abs(value_int16(v)));
break;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(result, value_uint16(v));
break;
}
case VALUE_TYPE_INT32: {
value_set_int(result, tk_abs(value_int(v)));
break;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(result, value_uint32(v));
break;
}
case VALUE_TYPE_INT64: {
value_set_int64(result, tk_abs(value_int64(v)));
break;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(result, value_uint64(v));
break;
}
default: {
value_set_double(result, tk_abs(value_double(v)));
break;
}
}
return RET_OK;
}
static ret_t func_len(fscript_t* fscript, fscript_args_t* args, value_t* result) {
char buff[64];
const char* str = NULL;
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
if (args->args->type == VALUE_TYPE_OBJECT) {
tk_object_t* obj = value_object(args->args);
value_set_uint32(result, tk_object_get_prop_int32(obj, "size", 0));
} else if (args->args->type == VALUE_TYPE_BINARY) {
binary_data_t* data = value_binary_data(args->args);
value_set_uint32(result, data != NULL ? data->size : 0);
} else if (args->args->type == VALUE_TYPE_STRING) {
value_set_uint32(result, tk_strlen(value_str(args->args)));
} else {
str = value_str_ex(args->args, buff, sizeof(buff) - 1);
value_set_uint32(result, tk_strlen(str));
}
return RET_OK;
}
static ret_t func_toupper(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
str_set(str, value_str(args->args));
str_to_upper(str);
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_eval(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
return fscript_eval(fscript->obj, value_str(args->args), result);
}
static ret_t func_tolower(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
str_set(str, value_str(args->args));
str_to_lower(str);
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_trim(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
str_set(str, value_str(args->args));
str_trim(str, " \t\r\n");
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_substr(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
const char* org = NULL;
uint32_t total_len = 0;
uint32_t from = 0;
uint32_t len = 0;
FSCRIPT_FUNC_CHECK(args->size == 3, RET_BAD_PARAMS);
org = value_str(args->args);
from = value_uint32(args->args + 1);
len = value_uint32(args->args + 2);
total_len = tk_strlen(org);
FSCRIPT_FUNC_CHECK(org != NULL, RET_BAD_PARAMS);
if (from < total_len) {
len = tk_min(len, (total_len - from));
str_set_with_len(str, org + from, len);
} else {
str_set(str, "");
}
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_replace(fscript_t* fscript, fscript_args_t* args, value_t* result) {
str_t* str = &(fscript->str);
const char* org = NULL;
const char* replace = NULL;
const char* replace_with = NULL;
FSCRIPT_FUNC_CHECK(args->size == 3, RET_BAD_PARAMS);
org = value_str(args->args);
replace = value_str(args->args + 1);
replace_with = value_str(args->args + 2);
FSCRIPT_FUNC_CHECK(org != NULL && replace != NULL && replace_with != NULL, RET_BAD_PARAMS);
str_set(str, org);
str_replace(str, replace, replace_with);
value_dup_str(result, str->str);
return RET_OK;
}
static ret_t func_contains(fscript_t* fscript, fscript_args_t* args, value_t* result) {
const char* org = NULL;
const char* target = NULL;
value_set_bool(result, FALSE);
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
org = value_str(args->args);
target = value_str(args->args + 1);
FSCRIPT_FUNC_CHECK(org != NULL && target != NULL, RET_BAD_PARAMS);
value_set_bool(result, strstr(org, target) != NULL);
return RET_OK;
}
static ret_t func_can_exec(fscript_t* fscript, fscript_args_t* args, value_t* result) {
char buff[64];
const char* cmd = NULL;
const char* cmd_args = NULL;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
cmd = value_str(args->args);
cmd_args = value_str_ex(args->args + 1, buff, sizeof(buff) - 1);
value_set_bool(result, tk_object_can_exec(fscript->obj, cmd, cmd_args));
return RET_OK;
}
static ret_t func_exec(fscript_t* fscript, fscript_args_t* args, value_t* result) {
char buff[64];
const char* cmd = NULL;
const char* cmd_args = NULL;
FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
cmd = value_str(args->args);
cmd_args = value_str_ex(args->args + 1, buff, sizeof(buff) - 1);
value_set_bool(result, tk_object_exec(fscript->obj, cmd, cmd_args) == RET_OK);
return RET_OK;
}
static ret_t func_sleep_ms(fscript_t* fscript, fscript_args_t* args, value_t* result) {
FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
sleep_ms(value_uint32(args->args));
value_set_bool(result, TRUE);
return RET_OK;
}
typedef struct _func_entry_t {
const char* name;
fscript_func_t func;
uint32_t max_args_nr;
} func_entry_t;
static const func_entry_t s_builtin_funcs[] = {{"func", func_function_def, 4},
{"return", func_return, 1},
{"print", func_print, 4},
{"expr", func_expr, 4},
{"=", func_set, 2},
{"get", func_get, 1},
{"set", func_set, 2},
{"set_local", func_set_local, 2},
{"max", func_max, 2},
{"min", func_min, 2},
{"==", func_eq, 2},
{"!=", func_not_eq, 2},
{">=", func_ge, 2},
{">", func_great, 2},
{"<=", func_le, 2},
{"<", func_less, 2},
{"!", func_not, 1},
{"minus", func_minus, 1},
{"||", func_or, 2},
{"and", func_and, 2},
{"can_exec", func_can_exec, 2},
{"exec", func_exec, 2},
{"join", func_join, 8},
{"one_of", func_one_of, 3},
{"if", func_if, 3},
{"while", func_while, 10},
{"until", func_until, 10},
{"repeat", func_repeat, 10},
{"for", func_for, 10},
{"for_in", func_for_in, 10},
{"repeat_times", func_repeat_times, 10},
{"int", func_int, 1},
{"i8", func_i8, 1},
{"i16", func_i16, 1},
{"i32", func_i32, 1},
{"i64", func_i64, 1},
{"u8", func_u8, 1},
{"u16", func_u16, 1},
{"u32", func_u32, 1},
{"u64", func_u64, 1},
{"f32", func_f32, 1},
{"f64", func_double, 1},
{"binary", func_binary, 1},
{"float", func_f32, 1},
{"number", func_double, 1},
{"double", func_double, 1},
{"iformat", func_iformat, 2},
{"fformat", func_fformat, 2},
{"unset", func_unset, 1},
{"str", func_str, 1},
{"string", func_str, 1},
{"sub", func_sub, 2},
{"assert", func_assert, 2},
{"substr", func_substr, 3},
{"has_error", func_has_error, 0},
{"get_last_error", func_get_last_error, 0},
{"clear_error", func_clear_error, 0},
{"sum", func_sum, 8},
{"tolower", func_tolower, 1},
{"toupper", func_toupper, 1},
{"eval", func_eval, 1},
{"trim", func_trim, 1},
{"&&", func_and, 2},
{"abs", func_abs, 1},
{"round", func_round, 1},
{"floor", func_floor, 1},
{"ceil", func_ceil, 1},
{"clamp", func_clamp, 3},
{"contains", func_contains, 2},
{"div", func_div, 2},
{"eq", func_eq, 2},
{"ge", func_ge, 2},
{"great", func_great, 2},
{"le", func_le, 2},
{"len", func_len, 1},
{"strlen", func_len, 1},
{"less", func_less, 2},
{"mul", func_mul, 2},
{"#", func_noop, 0},
{"noop", func_noop, 0},
{"seq", func_noop, 4},
{"not", func_not, 1},
{"or", func_or, 2},
{"random", func_random, 2},
{"replace", func_replace, 3},
{"/", func_div, 2},
{"%", func_mod, 2},
{"*", func_mul, 2},
{"-", func_sub, 2},
{"+", func_sum, 8},
{"sleep_ms", func_sleep_ms, 1}};
static general_factory_t* s_global_funcs;
fscript_func_t fscript_find_func(fscript_t* fscript, const char* name, uint32_t size) {
uint32_t i = 0;
fscript_func_t func = NULL;
char func_name[TK_NAME_LEN + 1];
char full_func_name[2 * TK_NAME_LEN + 1];
tk_object_t* obj = fscript->obj;
tk_strncpy(func_name, name, tk_min(size, TK_NAME_LEN));
for (i = 0; i < ARRAY_SIZE(s_builtin_funcs); i++) {
const func_entry_t* iter = s_builtin_funcs + i;
if (tk_str_eq(iter->name, func_name)) {
func = iter->func;
break;
}
}
if (func == NULL) {
tk_snprintf(full_func_name, sizeof(full_func_name) - 1, "%s%s", STR_FSCRIPT_FUNCTION_PREFIX,
func_name);
func = (fscript_func_t)tk_object_get_prop_pointer(obj, full_func_name);
}
if (func == NULL && s_global_funcs != NULL) {
func = (fscript_func_t)general_factory_find(s_global_funcs, func_name);
}
return func;
}
static tk_object_t* s_custom_events;
uint32_t fscript_find_event(const char* name) {
uint32_t etype = EVT_NONE;
return_value_if_fail(name != NULL, EVT_NONE);
if (s_custom_events != NULL) {
etype = tk_object_get_prop_uint32(s_custom_events, name, EVT_NONE);
}
return etype;
}
static ret_t fscript_func_call_init_func(fscript_func_call_t* call, tk_object_t* obj,
tk_object_t* funcs_def, const char* name, uint32_t size) {
uint32_t i = 0;
fscript_func_t func = NULL;
char func_name[TK_NAME_LEN + 1];
char full_func_name[2 * TK_NAME_LEN + 1];
tk_strncpy(func_name, name, tk_min(size, TK_NAME_LEN));
for (i = 0; i < ARRAY_SIZE(s_builtin_funcs); i++) {
const func_entry_t* iter = s_builtin_funcs + i;
if (tk_str_eq(iter->name, func_name)) {
call->func = iter->func;
func_args_init(&(call->args), iter->max_args_nr);
return RET_OK;
}
}
if (func == NULL && s_global_funcs != NULL) {
func = (fscript_func_t)general_factory_find(s_global_funcs, func_name);
}
if (func == NULL) {
value_t v;
if (tk_object_get_prop(obj, func_name, &v) == RET_OK && v.type == VALUE_TYPE_FUNC_DEF) {
fscript_function_def_t* def = (fscript_function_def_t*)value_func_def(&v);
if (def != NULL) {
func = func_function;
call->ctx = def;
}
}
}
if (func == NULL) {
tk_snprintf(full_func_name, sizeof(full_func_name) - 1, "%s%s", STR_FSCRIPT_FUNCTION_PREFIX,
func_name);
func = (fscript_func_t)tk_object_get_prop_pointer(obj, full_func_name);
}
if (func == NULL && funcs_def != NULL) {
value_t v;
if (tk_object_get_prop(funcs_def, func_name, &v) == RET_OK) {
func = func_function;
call->ctx = value_func_def(&v);
}
}
if (func == NULL) {
func = func_noop;
}
call->func = func;
return RET_OK;
}
static fscript_func_call_t* fscript_func_call_create(fscript_parser_t* parser, const char* name,
uint32_t size) {
uint32_t mem_size = sizeof(fscript_func_call_t);
fscript_func_call_t* call = NULL;
if (parser->keep_func_name) {
mem_size += size + 1;
}
call = TKMEM_ALLOC(mem_size);
return_value_if_fail(call != NULL, NULL);
memset(call, 0x00, mem_size);
if (parser->keep_func_name) {
char* p = (char*)call + sizeof(fscript_func_call_t);
memcpy(p, name, size);
}
call->row = parser->row;
call->col = parser->col;
fscript_func_call_init_func(call, parser->obj, parser->funcs_def, name, size);
if (call->func == func_noop) {
call->func = func_pending;
call->ctx = tk_strdup(name);
}
return call;
}
ret_t fscript_global_ensure_global_object(void) {
if (s_global_obj == NULL) {
tk_object_t* obj = object_default_create_ex(FALSE);
return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
s_global_obj = object_locker_create(obj);
TK_OBJECT_UNREF(obj);
}
return RET_OK;
}
tk_object_t* fscript_get_global_object(void) {
fscript_global_ensure_global_object();
return s_global_obj;
}
ret_t fscript_set_global_object(tk_object_t* obj) {
tk_object_t* old_global_obj = s_global_obj;
return_value_if_fail(obj != s_global_obj, RET_BAD_PARAMS);
if (obj != NULL) {
TK_OBJECT_REF(obj);
}
s_global_obj = obj;
TK_OBJECT_UNREF(old_global_obj);
return RET_OK;
}
ret_t fscript_global_init(void) {
fscript_global_ensure_global_object();
if (s_consts_obj == NULL) {
tk_object_t* obj = object_default_create_ex(FALSE);
return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
s_consts_obj = object_locker_create(obj);
TK_OBJECT_UNREF(obj);
}
return RET_OK;
}
ret_t fscript_global_deinit(void) {
TK_OBJECT_UNREF(s_consts_obj);
TK_OBJECT_UNREF(s_global_obj);
TK_OBJECT_UNREF(s_custom_events);
general_factory_destroy(s_global_funcs);
s_global_funcs = NULL;
return RET_OK;
}
ret_t fscript_register_funcs(const general_factory_table_t* table) {
return_value_if_fail(table != NULL, RET_BAD_PARAMS);
if (s_global_funcs == NULL) {
s_global_funcs = general_factory_create();
}
return general_factory_register_table(s_global_funcs, table);
}
ret_t fscript_register_const_value(const char* name, const value_t* value) {
return_value_if_fail(name != NULL && value != NULL, RET_BAD_PARAMS);
return_value_if_fail(s_consts_obj != NULL, RET_BAD_PARAMS);
return tk_object_set_prop(s_consts_obj, name, value);
}
ret_t fscript_register_const_int(const char* name, int value) {
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
return_value_if_fail(s_consts_obj != NULL, RET_BAD_PARAMS);
return tk_object_set_prop_int(s_consts_obj, name, value);
}
ret_t fscript_register_const_double(const char* name, double value) {
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
return_value_if_fail(s_consts_obj != NULL, RET_BAD_PARAMS);
return tk_object_set_prop_double(s_consts_obj, name, value);
}
ret_t fscript_register_func(const char* name, fscript_func_t func) {
return_value_if_fail(name != NULL && func != NULL, RET_BAD_PARAMS);
if (s_global_funcs == NULL) {
s_global_funcs = general_factory_create();
}
return general_factory_register(s_global_funcs, name, (tk_create_t)func);
}
ret_t fscript_register_event(const char* name, uint32_t etype) {
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
if (fscript_find_event(name) != EVT_NONE) {
return RET_FOUND;
}
if (s_custom_events == NULL) {
s_custom_events = object_default_create();
}
return tk_object_set_prop_uint32(s_custom_events, name, etype);
}
double tk_expr_eval(const char* expr) {
value_t v;
tk_object_t* obj = NULL;
value_set_double(&v, 0);
return_value_if_fail(expr != NULL, 0);
obj = object_default_create();
fscript_eval(obj, expr, &v);
TK_OBJECT_UNREF(obj);
return value_double(&v);
}
#endif
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/color.h
|
/**
* File: color.h
* Author: AWTK Develop Team
* Brief: color structs.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COLOR_H
#define TK_COLOR_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class rgba_t
* 颜色的四个通道。
*
*/
typedef struct _rgba_t {
/**
* @property {uint8_t} r
* @annotation ["readable","writable"]
* 红色。
*/
uint8_t r;
/**
* @property {uint8_t} g
* @annotation ["readable","writable"]
* 绿色。
*/
uint8_t g;
/**
* @property {uint8_t} b
* @annotation ["readable","writable"]
* 蓝色。
*/
uint8_t b;
/**
* @property {uint8_t} a
* @annotation ["readable","writable"]
* alpha。
*/
uint8_t a;
} rgba_t;
/**
* @class color_t
* 颜色。
* @annotation ["scriptable"]
*
*/
typedef union _color_t {
/**
* @property {rgba_t} rgba
* @annotation ["readable", "writable"]
* 颜色的RGBA值。
*/
rgba_t rgba;
/**
* @property {uint32_t} color
* @annotation ["readable", "writable", "scriptable"]
* 颜色的数值。
*/
uint32_t color;
} color_t;
/**
* @method color_init
* 初始化颜色对象。
* @annotation ["constructor"]
* @param {uint8_t} r 红色。
* @param {uint8_t} g 绿色。
* @param {uint8_t} b 蓝色。
* @param {uint8_t} a alpha。
*
* @return {color_t} 颜色对象。
*/
color_t color_init(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
/**
* @method color_create
* 创建color对象。
*
* > 主要供脚本语言使用。
*
* @annotation ["constructor", "scriptable", "gc"]
* @param {uint8_t} r 红色通道。
* @param {uint8_t} g 绿色通道。
* @param {uint8_t} b 蓝色通道。
* @param {uint8_t} a alpha通道。
*
* @return {color_t*} color对象。
*/
color_t* color_create(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
/**
* @method color_from_str
* 创建color对象。
*
* > 主要供脚本语言使用。
*
* @annotation ["scriptable"]
* @param {color_t*} c color对象。
* @param {const char*} str css类似的颜色值。
*
* @return {color_t*} color对象。
*/
color_t* color_from_str(color_t* c, const char* str);
/**
* @method color_r
*
* 获取红色通道的值。
*
* > 主要供脚本语言使用。
*
* @annotation ["scriptable"]
* @param {color_t*} c color对象。
*
* @return {uint8_t} 返回红色通道的值。
*
*/
uint8_t color_r(color_t* c);
/**
* @method color_g
*
* 获取绿色通道的值。
*
* > 主要供脚本语言使用。
*
* @annotation ["scriptable"]
* @param {color_t*} c color对象。
*
* @return {uint8_t} 返回绿色通道的值。
*
*/
uint8_t color_g(color_t* c);
/**
* @method color_b
*
* 获取蓝色通道的值。
*
* > 主要供脚本语言使用。
*
* @annotation ["scriptable"]
* @param {color_t*} c color对象。
*
* @return {uint8_t} 返回蓝色通道的值。
*
*/
uint8_t color_b(color_t* c);
/**
* @method color_a
*
* 获取alpha通道的值。
*
* > 主要供脚本语言使用。
*
* @annotation ["scriptable"]
* @param {color_t*} c color对象。
*
* @return {uint8_t} 返回alpha通道的值。
*
*/
uint8_t color_a(color_t* c);
/**
* @method color_get_color
*
* 获取颜色值。
*
* > 主要供脚本语言使用。
*
* @annotation ["scriptable"]
* @param {color_t*} c color对象。
*
* @return {uint32_t} 返回颜色值。
*
*/
uint32_t color_get_color(color_t* c);
/**
* @method color_cast
* 转换为color对象。
*
* > 供脚本语言使用。
* @annotation ["cast", "scriptable"]
* @param {color_t*} color color对象。
*
* @return {color_t*} color对象。
*/
color_t* color_cast(color_t* color);
/**
* @method color_destroy
*
* 销毁color对象。
* > 主要供脚本语言使用。
*
* @annotation ["deconstructor", "scriptable", "gc"]
* @param {color_t*} c color对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t color_destroy(color_t* c);
#define TK_COLOR_HEX_LEN 11
#define TK_COLOR_RGBA_LEN 31
/**
* @method color_hex_str
* 获取16进制格式表示的颜色
* @param {color_t} c color对象。
* @param {char*} str 内存。
*
* @return {const char*} 获取16进制字符串表示的颜色。
*/
const char* color_hex_str(color_t c, char str[TK_COLOR_HEX_LEN + 1]);
/**
* @method color_rgba_str
* 获取rgba格式表示的颜色
* @param {color_t} c color对象。
* @param {char*} str 内存。
*
* @return {const char*} 获取rgba格式表示的颜色。
*/
const char* color_rgba_str(color_t c, char str[TK_COLOR_RGBA_LEN + 1]);
END_C_DECLS
#endif /*TK_COLOR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/timer_info.h
|
/**
* File: timer_info.h
* Author: AWTK Develop Team
* Brief: timer info
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TIMER_INFO_H
#define TK_TIMER_INFO_H
#include "tkc/object.h"
BEGIN_C_DECLS
struct _timer_info_t;
typedef struct _timer_info_t timer_info_t;
struct _timer_manager_t;
typedef struct _timer_manager_t timer_manager_t;
typedef tk_get_time_ms_t timer_get_time_t;
typedef ret_t (*timer_func_t)(const timer_info_t* timer);
typedef enum _timer_info_type_t {
TIMER_INFO_NORMAL = 0,
TIMER_INFO_WIDGET_ADD,
} timer_info_type_t;
/**
* @class timer_info_t
* @parent tk_object_t
* @annotation ["scriptable"]
* 单个定时器的信息。
*
*/
struct _timer_info_t {
tk_object_t object;
/**
* @property {timer_func_t} on_timer
* @annotation ["readable"]
* 定时器回调函数。
*/
timer_func_t on_timer;
/**
* @property {void*} ctx
* @annotation ["readable", "scriptable"]
* 定时器回调函数的上下文
*
*/
void* ctx;
/**
* @property {void*} extra_ctx
* @annotation ["readable", "scriptable"]
* 定时器回调函数的上下文
*
*/
void* extra_ctx;
/**
* @property {uint32_t} id
* @annotation ["readable", "scriptable"]
* 定时器的ID
*
* > 为TK\_INVALID\_ID时表示无效定时器。
*/
uint32_t id;
/**
* @property {uint64_t} now
* @annotation ["readable", "scriptable"]
* 当前时间(相对时间，单位为毫秒)。
*
*/
uint64_t now;
/**
* @property {uint64_t} start
* @annotation ["readable"]
* 起始时间(相对时间，单位为毫秒)。
*
*/
uint64_t start;
/**
* @property {uint32_t} duration
* @annotation ["readable"]
* 时间间隔(单位为毫秒)。
*
*/
uint32_t duration;
/**
* @property {tk_destroy_t} on_destroy
* @annotation ["readable"]
* 定时器销毁时的回调函数。
*/
tk_destroy_t on_destroy;
/**
* @property {void*} on_destroy_ctx
* @annotation ["readable"]
* 定时器销毁时的回调函数上下文。
*/
void* on_destroy_ctx;
/**
* @property {bool_t} suspend
* @annotation ["readable"]
* 定时器是否为挂起状态。
*/
bool_t suspend;
/*private*/
bool_t busy;
uint16_t timer_info_type;
uint64_t last_dispatch_time;
timer_manager_t* timer_manager;
};
/**
* @method timer_info_cast
* 转换为timer_info对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
* @param {timer_info_t*} timer timer_info对象。
*
* @return {timer_info_t*} timer_info对象。
*/
timer_info_t* timer_info_cast(timer_info_t* timer);
/*internal use*/
int timer_info_compare_by_id(const void* a, const void* b);
int timer_info_compare_by_ctx(const void* a, const void* b);
int timer_info_compare_by_ctx_and_type(const void* a, const void* b);
timer_info_t* timer_info_init_dummy(timer_info_t* timer, uint32_t id);
timer_info_t* timer_info_init_dummy_with_ctx_and_type(timer_info_t* timer, uint16_t type,
void* ctx);
timer_info_t* timer_info_create(timer_manager_t* tm, uint32_t id, timer_func_t on_timer, void* ctx,
uint32_t duration, uint16_t timer_info_type);
ret_t timer_info_on_timer(timer_info_t* timer, uint64_t now);
bool_t timer_info_is_available(timer_info_t* timer, uint64_t now);
#define TIMER_INFO(o) ((timer_info_t*)(o))
END_C_DECLS
#endif /*TK_TIMER_INFO_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/slist.c
|
/**
* File: slist.c
* Author: AWTK Develop Team
* Brief: single link list
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-11 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/slist.h"
static slist_node_t* slist_node_create(void* data) {
slist_node_t* node = TKMEM_ZALLOC(slist_node_t);
return_value_if_fail(node != NULL, NULL);
node->data = data;
return node;
}
static ret_t slist_node_destroy(slist_node_t* node, tk_destroy_t destroy) {
return_value_if_fail(node != NULL && destroy != NULL, RET_OK);
destroy(node->data);
TKMEM_FREE(node);
return RET_OK;
}
slist_t* slist_create(tk_destroy_t destroy, tk_compare_t compare) {
slist_t* slist = TKMEM_ZALLOC(slist_t);
return_value_if_fail(slist != NULL, NULL);
return slist_init(slist, destroy, compare);
}
slist_t* slist_init(slist_t* slist, tk_destroy_t destroy, tk_compare_t compare) {
return_value_if_fail(slist != NULL, NULL);
slist->first = NULL;
slist->destroy = destroy != NULL ? destroy : dummy_destroy;
slist->compare = compare != NULL ? compare : pointer_compare;
return slist;
}
void* slist_find_ex(slist_t* slist, tk_compare_t compare, void* ctx) {
slist_node_t* iter = NULL;
tk_compare_t real_compare = NULL;
return_value_if_fail(slist != NULL, NULL);
if (slist->first == NULL) {
return NULL;
}
real_compare = (compare != NULL) ? compare : slist->compare;
iter = slist->first;
while (iter != NULL) {
if (real_compare(iter->data, ctx) == 0) {
return iter->data;
}
iter = iter->next;
}
return NULL;
}
void* slist_find(slist_t* slist, void* ctx) {
return slist_find_ex(slist, NULL, ctx);
}
ret_t slist_remove_ex(slist_t* slist, tk_compare_t compare, void* ctx, int32_t remove_size) {
int32_t n = remove_size;
slist_node_t* iter = NULL;
slist_node_t* prev = NULL;
slist_node_t* next = NULL;
return_value_if_fail(slist != NULL, RET_BAD_PARAMS);
iter = slist->first;
prev = slist->first;
while (iter != NULL) {
if (compare(iter->data, ctx) == 0) {
if (iter == slist->first) {
slist->first = slist->first->next;
} else {
prev->next = iter->next;
}
next = iter->next;
slist_node_destroy(iter, slist->destroy);
iter = next;
n--;
if (n == 0) {
return RET_OK;
}
} else {
prev = iter;
iter = iter->next;
}
}
return remove_size == n ? RET_NOT_FOUND : RET_OK;
}
ret_t slist_remove(slist_t* slist, void* ctx) {
return slist_remove_ex(slist, slist->compare, ctx, 1);
}
ret_t slist_append(slist_t* slist, void* data) {
slist_node_t* iter = NULL;
slist_node_t* node = NULL;
return_value_if_fail(slist != NULL, RET_BAD_PARAMS);
node = slist_node_create(data);
return_value_if_fail(node != NULL, RET_OOM);
iter = slist->first;
if (iter == NULL) {
slist->first = node;
} else {
while (iter->next != NULL) {
iter = iter->next;
}
iter->next = node;
}
return RET_OK;
}
ret_t slist_prepend(slist_t* slist, void* data) {
slist_node_t* node = NULL;
return_value_if_fail(slist != NULL, RET_BAD_PARAMS);
node = slist_node_create(data);
return_value_if_fail(node != NULL, RET_OOM);
node->next = slist->first;
slist->first = node;
return RET_OK;
}
ret_t slist_foreach(slist_t* slist, tk_visit_t visit, void* ctx) {
ret_t ret = RET_OK;
slist_node_t* iter = NULL;
slist_node_t* prev_iter = NULL;
return_value_if_fail(slist != NULL && visit != NULL, RET_BAD_PARAMS);
iter = slist->first;
while (iter != NULL) {
ret = visit(ctx, iter->data);
if (ret == RET_REMOVE) {
slist_node_t* next = iter->next;
if (prev_iter == NULL) {
slist->first = next;
} else {
prev_iter->next = next;
}
slist_node_destroy(iter, slist->destroy);
iter = next;
continue;
} else if (ret != RET_OK) {
break;
}
prev_iter = iter;
iter = iter->next;
}
return RET_OK;
}
void* slist_tail_pop(slist_t* slist) {
void* data = NULL;
slist_node_t* iter = NULL;
slist_node_t* last_iter = NULL;
return_value_if_fail(slist != NULL, NULL);
iter = slist->first;
return_value_if_fail(iter != NULL, NULL);
if (iter->next == NULL) {
slist->first = NULL;
} else {
while (iter->next != NULL) {
last_iter = iter;
iter = iter->next;
}
last_iter->next = NULL;
}
data = iter->data;
TKMEM_FREE(iter);
return data;
}
void* slist_head_pop(slist_t* slist) {
void* data = NULL;
slist_node_t* iter = NULL;
return_value_if_fail(slist != NULL, NULL);
iter = slist->first;
if (iter == NULL) {
return NULL;
}
slist->first = iter->next;
data = iter->data;
TKMEM_FREE(iter);
return data;
}
void* slist_tail(slist_t* slist) {
slist_node_t* iter = NULL;
return_value_if_fail(slist != NULL, NULL);
iter = slist->first;
return_value_if_fail(iter != NULL, NULL);
while (iter->next != NULL) {
iter = iter->next;
}
return iter->data;
}
void* slist_head(slist_t* slist) {
slist_node_t* iter = NULL;
return_value_if_fail(slist != NULL, NULL);
iter = slist->first;
if (iter == NULL) {
return NULL;
}
return iter->data;
}
bool_t slist_is_empty(slist_t* slist) {
return_value_if_fail(slist != NULL, TRUE);
return slist->first == NULL;
}
int32_t slist_size(slist_t* slist) {
int32_t size = 0;
slist_node_t* iter = NULL;
return_value_if_fail(slist != NULL, 0);
iter = slist->first;
while (iter != NULL) {
size++;
iter = iter->next;
}
return size;
}
int32_t slist_count(slist_t* slist, void* ctx) {
int32_t size = 0;
slist_node_t* iter = NULL;
return_value_if_fail(slist != NULL, 0);
iter = slist->first;
while (iter != NULL) {
if (slist->compare(iter->data, ctx) == 0) {
size++;
}
iter = iter->next;
}
return size;
}
ret_t slist_deinit(slist_t* slist) {
return slist_remove_all(slist);
}
ret_t slist_remove_all(slist_t* slist) {
return_value_if_fail(slist != NULL, RET_BAD_PARAMS);
if (slist->first != NULL) {
slist_node_t* iter = slist->first;
while (iter != NULL) {
slist_node_t* next = iter->next;
slist_node_destroy(iter, slist->destroy);
iter = next;
}
slist->first = NULL;
}
return RET_OK;
}
ret_t slist_destroy(slist_t* slist) {
return_value_if_fail(slist != NULL, RET_BAD_PARAMS);
slist_deinit(slist);
TKMEM_FREE(slist);
return RET_OK;
}
ret_t slist_insert(slist_t* slist, uint32_t index, void* data) {
slist_node_t* node = NULL;
slist_node_t* iter = NULL;
slist_node_t* prev = NULL;
return_value_if_fail(slist != NULL, RET_BAD_PARAMS);
if (index == 0 || slist->first == NULL) {
return slist_prepend(slist, data);
}
iter = slist->first;
prev = slist->first;
while (iter != NULL && index > 0) {
index--;
prev = iter;
iter = iter->next;
}
node = slist_node_create(data);
node->next = prev->next;
prev->next = node;
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_simple.h
|
/**
* File: mem_allocator_simple.h
* Author: AWTK Develop Team
* Brief: mem_allocator_simple
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_SIMPLE_H
#define TK_MEM_ALLOCATOR_SIMPLE_H
#include "tkc/mem_allocator.h"
BEGIN_C_DECLS
typedef struct _free_node_t {
uint32_t size;
struct _free_node_t* next;
struct _free_node_t* prev;
} free_node_t;
typedef struct _mem_info_t {
char* buffer;
uint32_t size;
uint32_t used_bytes;
uint32_t used_block_nr;
uint32_t used_max_bytes;
uint32_t used_max_block_nr;
free_node_t* free_list;
} mem_info_t;
/**
* @class mem_allocator_simple_t
* @parent mem_allocator_t
*
* 简单的内存分配器。
*
*/
typedef struct _mem_allocator_simple_t {
mem_allocator_t allocator;
mem_info_t info;
} mem_allocator_simple_t;
#define MEM_ALLOCATOR_SIMPLE(allocator) ((mem_allocator_simple_t*)(allocator))
#define MIN_SIZE TK_ROUND_TO_MACH(sizeof(free_node_t))
static inline uint32_t real_size(uint32_t size) {
return size > MIN_SIZE ? size : MIN_SIZE;
}
static void* tk_alloc_impl(mem_allocator_t* allocator, uint32_t s) {
mem_info_t* info = &(MEM_ALLOCATOR_SIMPLE(allocator)->info);
free_node_t* iter = NULL;
uint32_t size = TK_ROUND_TO_MACH(real_size(s + sizeof(uint32_t)));
/*查找第一个满足条件的空闲块*/
for (iter = info->free_list; iter != NULL; iter = iter->next) {
if (iter->size >= size) {
break;
}
}
if (iter == NULL) {
return NULL;
}
/*如果找到的空闲块刚好满足需求，就从空闲块链表中移出它*/
if (iter->size < (size + MIN_SIZE)) {
if (info->free_list == iter) {
info->free_list = iter->next;
}
if (iter->prev != NULL) {
iter->prev->next = iter->next;
}
if (iter->next != NULL) {
iter->next->prev = iter->prev;
}
} else {
/*如果找到的空闲块比较大，就把它拆成两个块，把多余的空闲内存放回去*/
free_node_t* new_iter = (free_node_t*)((char*)iter + size);
new_iter->size = iter->size - size;
new_iter->next = iter->next;
new_iter->prev = iter->prev;
if (iter->prev != NULL) {
iter->prev->next = new_iter;
}
if (iter->next != NULL) {
iter->next->prev = new_iter;
}
if (info->free_list == iter) {
info->free_list = new_iter;
}
iter->size = size;
}
/*返回可用的内存*/
info->used_block_nr++;
info->used_bytes += iter->size;
if (info->used_block_nr > info->used_max_block_nr) {
info->used_max_block_nr = info->used_block_nr;
}
if (info->used_bytes > info->used_max_bytes) {
info->used_max_bytes = info->used_bytes;
}
return (char*)iter + sizeof(uint32_t);
}
static void node_merge2(mem_info_t* info, free_node_t* prev, free_node_t* next) {
return_if_fail(prev != NULL && next != NULL && prev->next == next);
prev->next = next->next;
if (next->next != NULL) {
next->next->prev = prev;
}
prev->size += next->size;
if (info->free_list == next) {
info->free_list = prev;
}
return;
}
static void node_merge(mem_info_t* info, free_node_t* iter) {
free_node_t* prev = iter->prev;
free_node_t* next = iter->next;
if (prev != NULL && ((char*)prev + prev->size) == (char*)iter) {
node_merge2(info, prev, iter);
node_merge(info, prev);
} else if (next != NULL && ((char*)iter + iter->size) == (char*)next) {
node_merge2(info, iter, next);
node_merge(info, iter);
}
return;
}
static void tk_free_impl(mem_allocator_t* allocator, void* ptr) {
uint32_t size = 0;
free_node_t* iter = NULL;
free_node_t* free_iter = NULL;
mem_info_t* info = &(MEM_ALLOCATOR_SIMPLE(allocator)->info);
if (ptr == NULL) {
return;
}
free_iter = (free_node_t*)((char*)ptr - sizeof(uint32_t));
size = free_iter->size;
free_iter->prev = NULL;
free_iter->next = NULL;
if (info->free_list == NULL) {
info->free_list = free_iter;
} else {
/*根据内存块地址的大小，把它插入到适当的位置。*/
for (iter = info->free_list; iter != NULL; iter = iter->next) {
if ((char*)iter > (char*)free_iter) {
free_iter->next = iter;
free_iter->prev = iter->prev;
if (iter->prev != NULL) {
iter->prev->next = free_iter;
}
iter->prev = free_iter;
if (info->free_list == iter) {
info->free_list = free_iter;
}
break;
}
if (iter->next == NULL) {
iter->next = free_iter;
free_iter->prev = iter;
break;
}
}
/*对相邻居的内存进行合并*/
node_merge(info, free_iter);
}
info->used_block_nr--;
info->used_bytes -= size;
return;
}
static void* tk_realloc_impl(mem_allocator_t* allocator, void* ptr, uint32_t size) {
void* new_ptr = NULL;
if (ptr != NULL) {
uint32_t up_size = size + MIN_SIZE;
uint32_t old_size = *(uint32_t*)((char*)ptr - sizeof(uint32_t)) - sizeof(uint32_t);
if ((old_size >= size) && (old_size <= up_size)) {
return ptr;
}
new_ptr = tk_alloc_impl(allocator, size);
if (new_ptr != NULL) {
memcpy(new_ptr, ptr, size < old_size ? size : old_size);
tk_free_impl(allocator, ptr);
}
} else {
new_ptr = tk_alloc_impl(allocator, size);
}
return new_ptr;
}
static ret_t tk_mem_init_impl(mem_allocator_t* allocator, void* buffer, uint32_t size) {
mem_info_t* info = &(MEM_ALLOCATOR_SIMPLE(allocator)->info);
return_value_if_fail(buffer != NULL && size > MIN_SIZE, RET_BAD_PARAMS);
if (info->buffer != NULL) {
return RET_FAIL;
}
memset(buffer, 0x00, size);
info->buffer = (char*)buffer;
info->size = size;
info->free_list = (free_node_t*)buffer;
info->free_list->prev = NULL;
info->free_list->next = NULL;
info->free_list->size = size;
info->used_block_nr = 0;
return RET_OK;
}
static inline void* mem_allocator_simple_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
return tk_alloc_impl(allocator, size);
}
static inline void* mem_allocator_simple_realloc(mem_allocator_t* allocator, void* ptr,
uint32_t size, const char* func, uint32_t line) {
return tk_realloc_impl(allocator, ptr, size);
}
static inline void mem_allocator_simple_free(mem_allocator_t* allocator, void* ptr) {
tk_free_impl(allocator, ptr);
}
static inline bool_t mem_allocator_simple_is_valid(mem_allocator_t* allocator) {
mem_info_t* info = &(MEM_ALLOCATOR_SIMPLE(allocator)->info);
return info->buffer != NULL && info->size > 0;
}
static inline bool_t mem_allocator_simple_contains(mem_allocator_t* allocator, void* ptr) {
char* p = (char*)ptr;
mem_info_t* info = &(MEM_ALLOCATOR_SIMPLE(allocator)->info);
return (p >= info->buffer && (p - info->buffer) < info->size);
}
static inline ret_t mem_allocator_simple_dump(mem_allocator_t* allocator) {
mem_info_t* info = &(MEM_ALLOCATOR_SIMPLE(allocator)->info);
log_debug("used: %u(max=%u) bytes %u(max=%u) blocks\n", info->used_bytes, info->used_max_bytes,
info->used_block_nr, info->used_max_block_nr);
(void)info;
return RET_OK;
}
static uint32_t mem_allocator_simple_get_mem_size(mem_allocator_t* allocator, void* ptr) {
free_node_t* free_iter = NULL;
return_value_if_fail(ptr != NULL, 0);
free_iter = (free_node_t*)((char*)ptr - sizeof(uint32_t));
return free_iter->size;
}
static inline ret_t mem_allocator_simple_destroy(mem_allocator_t* allocator) {
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_simple_vtable = {
.alloc = mem_allocator_simple_alloc,
.realloc = mem_allocator_simple_realloc,
.free = mem_allocator_simple_free,
.dump = mem_allocator_simple_dump,
.destroy = mem_allocator_simple_destroy};
static inline mem_allocator_t* mem_allocator_simple_init(mem_allocator_simple_t* allocator_simple,
void* buffer, uint32_t size) {
mem_allocator_t* allocator = MEM_ALLOCATOR(allocator_simple);
return_value_if_fail(allocator != NULL, NULL);
memset(allocator_simple, 0x00, sizeof(mem_allocator_simple_t));
allocator->vt = &s_mem_allocator_simple_vtable;
return_value_if_fail(tk_mem_init_impl(allocator, buffer, size) == RET_OK, NULL);
return allocator;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_SIMPLE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_mem.c
|
/**
* File: data_reader.c
* Author: AWTK Develop Team
* Brief: data_reader
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License mem for more details.
*
*/
/**
* History:
* ================================================================
* 2020-12-23 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/data_reader_mem.h"
typedef struct _data_reader_mem_t {
data_reader_t data_reader;
uint32_t size;
const uint8_t* data;
} data_reader_mem_t;
static int32_t data_reader_mem_read(data_reader_t* reader, uint64_t offset, void* data,
uint32_t size) {
uint32_t available_size = 0;
data_reader_mem_t* mem = (data_reader_mem_t*)reader;
return_value_if_fail(mem->data != NULL, 0);
if (offset >= mem->size) {
return 0;
}
available_size = mem->size - offset;
size = tk_min(available_size, size);
memcpy(data, mem->data + offset, size);
return size;
}
static uint64_t data_reader_mem_get_size(data_reader_t* reader) {
data_reader_mem_t* mem = (data_reader_mem_t*)reader;
return mem->size;
}
static ret_t data_reader_mem_destroy(data_reader_t* reader) {
TKMEM_FREE(reader);
return RET_OK;
}
static const data_reader_vtable_t s_data_reader_mem_vtable = {
.read = data_reader_mem_read,
.get_size = data_reader_mem_get_size,
.destroy = data_reader_mem_destroy,
};
data_reader_t* data_reader_mem_create(const char* memname) {
int32_t nr = 0;
uint32_t size = 0;
const char* p = NULL;
const uint8_t* data = NULL;
data_reader_mem_t* mem = NULL;
return_value_if_fail(memname != NULL, NULL);
mem = TKMEM_ZALLOC(data_reader_mem_t);
return_value_if_fail(mem != NULL, NULL);
p = strstr(memname, "://");
if (p != NULL) {
p += 3;
memname = p;
}
nr = tk_sscanf(memname, "%p:%u", &data, &size);
if (nr == 2 && data != NULL) {
mem->size = size;
mem->data = data;
mem->data_reader.vt = &s_data_reader_mem_vtable;
} else {
TKMEM_FREE(mem);
}
return (data_reader_t*)mem;
}
const char* data_reader_mem_build_url(const void* buffer, uint32_t size, char url[MAX_PATH + 1]) {
return_value_if_fail(buffer != NULL, NULL);
tk_snprintf(url, MAX_PATH, "mem://%p:%u", buffer, size);
return url;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/log.c
|
/**
* File: log.c
* Author: AWTK Develop Team
* Brief: log functions
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
#include "tkc/types_def.h"
#include "tkc/log.h"
#include "tkc/mem.h"
#include "tkc/utils.h"
static tk_log_level_t s_log_level = LOG_LEVEL_DEBUG;
ret_t log_set_log_level(tk_log_level_t log_level) {
s_log_level = log_level;
return RET_OK;
}
tk_log_level_t log_get_log_level(void) {
return s_log_level;
}
int32_t log_dummy(const char* fmt, ...) {
return 0;
}
#ifndef WITHOUT_FSCRIPT
static void* s_log_hook_ctx = NULL;
static tk_log_hook_t s_log_hook = NULL;
ret_t log_notify(tk_log_level_t level, const char* format, ...) {
va_list va;
if (s_log_hook != NULL) {
va_start(va, format);
s_log_hook(s_log_hook_ctx, level, format, va);
va_end(va);
}
return RET_OK;
}
ret_t log_set_hook(tk_log_hook_t log, void* ctx) {
s_log_hook = log;
s_log_hook_ctx = ctx;
return RET_OK;
}
#else
ret_t log_notify(tk_log_level_t level, const char* format, ...) {
return RET_OK;
}
ret_t log_set_hook(tk_log_hook_t log, void* ctx) {
return RET_OK;
}
#endif /*WITHOUT_FSCRIPT*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_rbuffer.h
|
/**
* File: object_rbuffer.h
* Author: AWTK Develop Team
* Brief: wrap rbuffer to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_RBUFFER_H
#define TK_OBJECT_RBUFFER_H
#include "tkc/object.h"
#include "tkc/buffer.h"
BEGIN_C_DECLS
/**
* @class object_rbuffer_t
* @parent tk_object_t
*
* 将rbuffer包装成object。
*
*/
typedef struct _object_rbuffer_t {
tk_object_t object;
/**
* @property {rbuffer_t*} rbuffer
* @annotation ["readable"]
* rbuffer对象。
*
*/
rbuffer_t* rbuffer;
/*private*/
rbuffer_t arbuffer;
} object_rbuffer_t;
/**
* @method object_rbuffer_create
*
* 创建rbuffer对象。
*
* @annotation ["constructor"]
* @param {const uint8_t*} data 缓冲区。
* @param {uint32_t} capacity 缓冲区的容量。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_rbuffer_create(const uint8_t* data, uint32_t capacity);
/**
* @method object_rbuffer_cast
* 转换为object_rbuffer对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_rbuffer对象。
*
* @return {object_rbuffer_t*} object_rbuffer对象。
*/
object_rbuffer_t* object_rbuffer_cast(tk_object_t* obj);
#define OBJECT_RBUFFER(obj) object_rbuffer_cast(obj)
#define OBJECT_RBUFFER_TYPE "object_rbuffer"
END_C_DECLS
#endif /*TK_OBJECT_RBUFFER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/iostream.c
|
/**
* File: tk_iostream.h
* Author: AWTK Develop Team
* Brief: input/ouput stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-27 Li XianJing <[email protected]> created
*
*/
#include "tkc/iostream.h"
tk_istream_t* tk_iostream_get_istream(tk_iostream_t* stream) {
return_value_if_fail(stream != NULL && stream->get_istream != NULL, NULL);
return stream->get_istream(stream);
}
tk_ostream_t* tk_iostream_get_ostream(tk_iostream_t* stream) {
return_value_if_fail(stream != NULL && stream->get_ostream != NULL, NULL);
return stream->get_ostream(stream);
}
int32_t tk_iostream_read(tk_iostream_t* stream, void* buff, uint32_t max_size) {
tk_istream_t* is = tk_iostream_get_istream(stream);
return tk_istream_read(is, buff, max_size);
}
int32_t tk_iostream_read_len(tk_iostream_t* stream, void* buff, uint32_t max_size,
uint32_t timeout_ms) {
tk_istream_t* is = tk_iostream_get_istream(stream);
return tk_istream_read_len(is, buff, max_size, timeout_ms);
}
int32_t tk_iostream_write(tk_iostream_t* stream, const void* buff, uint32_t max_size) {
tk_ostream_t* os = tk_iostream_get_ostream(stream);
return tk_ostream_write(os, buff, max_size);
}
int32_t tk_iostream_write_len(tk_iostream_t* stream, const void* buff, uint32_t max_size,
uint32_t timeout_ms) {
tk_ostream_t* os = tk_iostream_get_ostream(stream);
return tk_ostream_write_len(os, buff, max_size, timeout_ms);
}
ret_t tk_iostream_unref(tk_iostream_t* stream) {
return tk_object_unref(TK_OBJECT(stream));
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_locker.h
|
/**
* File: object_locker.h
* Author: AWTK Develop Team
* Brief: decorate object with lock
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-12 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_LOCKER_H
#define TK_OBJECT_LOCKER_H
#include "tkc/object.h"
#include "tkc/mutex_nest.h"
BEGIN_C_DECLS
/**
* @class object_locker_t
* @parent tk_object_t
*
* 对现有的object对象进行装饰，添加访问互斥功能。
*
*/
typedef struct _object_locker_t {
tk_object_t object;
/*private*/
tk_mutex_nest_t* mutex;
tk_object_t* obj;
} object_locker_t;
/**
* @method object_locker_create
*
* 创建对象。
*
* @annotation ["constructor"]
*
* @param {tk_object_t*} obj 待装饰的对象。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_locker_create(tk_object_t* obj);
/**
* @method object_locker_cast
* 转换为object_locker对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_locker对象。
*
* @return {object_locker_t*} object_locker对象。
*/
object_locker_t* object_locker_cast(tk_object_t* obj);
#define OBJECT_LOCKER(obj) object_locker_cast(obj)
#define OBJECT_LOCKER_TYPE "object_locker"
END_C_DECLS
#endif /*TK_OBJECT_LOCKER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object.c
|
/**
* File: object.c
* Author: AWTK Develop Team
* Brief: reference count object
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-09 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/event.h"
#include "tkc/object.h"
#ifndef WITHOUT_FSCRIPT
#include "tkc/fscript.h"
#endif /*WITHOUT_FSCRIPT*/
#include "tkc/named_value.h"
ret_t tk_object_set_name(tk_object_t* obj, const char* name) {
ret_t ret = RET_OK;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
obj->name = tk_str_copy(obj->name, name);
return ret;
}
static ret_t object_destroy(tk_object_t* obj) {
ret_t ret = RET_OK;
event_t e = event_init(EVT_DESTROY, obj);
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
emitter_dispatch((emitter_t*)obj, (event_t*)(&e));
if (obj->vt->on_destroy != NULL) {
ret = obj->vt->on_destroy(obj);
}
emitter_deinit((emitter_t*)obj);
TKMEM_FREE(obj->name);
memset(obj, 0x00, obj->vt->size);
TKMEM_FREE(obj);
return ret;
}
tk_object_t* tk_object_create_ex(const object_vtable_t* vt, uint32_t extra_data_size) {
uint32_t size = 0;
tk_object_t* obj = NULL;
return_value_if_fail(vt != NULL && vt->size >= sizeof(tk_object_t), NULL);
size = vt->size + extra_data_size;
obj = (tk_object_t*)TKMEM_ALLOC(size);
return_value_if_fail(obj != NULL, NULL);
memset(obj, 0x00, size);
obj->vt = vt;
obj->ref_count = 1;
emitter_init((emitter_t*)obj);
return obj;
}
tk_object_t* tk_object_create(const object_vtable_t* vt) {
tk_object_t* obj = NULL;
return_value_if_fail(vt != NULL && vt->size >= sizeof(tk_object_t), NULL);
obj = (tk_object_t*)TKMEM_ALLOC(vt->size);
return_value_if_fail(obj != NULL, NULL);
memset(obj, 0x00, vt->size);
obj->vt = vt;
obj->ref_count = 1;
emitter_init((emitter_t*)obj);
return obj;
}
ret_t tk_object_unref(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count > 0, RET_BAD_PARAMS);
return_value_if_fail(!(obj->visiting), RET_BUSY);
if (obj->ref_count == 1) {
object_destroy(obj);
} else {
obj->ref_count--;
}
return RET_OK;
}
tk_object_t* tk_object_ref(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, NULL);
obj->ref_count++;
return obj;
}
tk_object_t* tk_object_clone(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->vt->clone != NULL, NULL);
return obj->vt->clone(obj);
}
static ret_t object_get_prop_by_name(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
return_value_if_fail(name != NULL && v != NULL, RET_BAD_PARAMS);
value_set_str(v, NULL);
if (obj->vt->get_prop != NULL) {
ret = obj->vt->get_prop(obj, name, v);
}
return ret;
}
static ret_t object_get_prop_by_path_with_len(tk_object_t* obj, const char* path, uint32_t len,
value_t* v) {
char* p = NULL;
char temp[MAX_PATH + 1];
const char* name = temp;
ret_t ret = RET_NOT_FOUND;
return_value_if_fail(len <= MAX_PATH, RET_BAD_PARAMS);
memcpy(temp, path, len);
temp[len] = '\0';
do {
p = strchr(name, '.');
if (p != NULL) {
*p = '\0';
}
if (object_get_prop_by_name(obj, name, v) != RET_OK) {
break;
}
if (p == NULL) {
ret = RET_OK;
break;
}
if (v->type == VALUE_TYPE_OBJECT) {
obj = value_object(v);
} else {
ret = RET_BAD_PARAMS;
break;
}
name = p + 1;
} while (p != NULL);
return ret;
}
ret_t tk_object_get_prop_by_path(tk_object_t* obj, const char* path, value_t* v) {
uint32_t len = 0;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
return_value_if_fail(path != NULL && v != NULL, RET_BAD_PARAMS);
len = strlen(path);
return object_get_prop_by_path_with_len(obj, path, len, v);
}
ret_t tk_object_get_prop(tk_object_t* obj, const char* name, value_t* v) {
return object_get_prop_by_name(obj, name, v);
}
const char* tk_object_get_prop_str(tk_object_t* obj, const char* name) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_str(&v);
} else {
return NULL;
}
}
void* tk_object_get_prop_pointer(tk_object_t* obj, const char* name) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_pointer(&v);
} else {
return NULL;
}
}
tk_object_t* tk_object_get_prop_object(tk_object_t* obj, const char* name) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_object(&v);
} else {
return NULL;
}
}
int32_t tk_object_get_prop_int(tk_object_t* obj, const char* name, int32_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_int(&v);
} else {
return defval;
}
}
bool_t tk_object_get_prop_bool(tk_object_t* obj, const char* name, bool_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_bool(&v);
} else {
return defval;
}
}
float_t tk_object_get_prop_float(tk_object_t* obj, const char* name, float_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_float(&v);
} else {
return defval;
}
}
double tk_object_get_prop_double(tk_object_t* obj, const char* name, double defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_double(&v);
} else {
return defval;
}
}
ret_t tk_object_notify_changed(tk_object_t* obj) {
event_t e = event_init(EVT_PROPS_CHANGED, obj);
return emitter_dispatch((emitter_t*)obj, &e);
}
ret_t tk_object_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
ret_t ret = RET_NOT_FOUND;
return_value_if_fail(name != NULL && v != NULL, RET_BAD_PARAMS);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, RET_BAD_PARAMS);
return_value_if_fail(!(obj->visiting), RET_BUSY);
if (obj->vt->set_prop != NULL) {
prop_change_event_t e;
e.name = name;
e.value = v;
e.e = event_init(EVT_PROP_WILL_CHANGE, obj);
emitter_dispatch((emitter_t*)obj, (event_t*)(&e));
ret = obj->vt->set_prop(obj, name, v);
if (ret == RET_OK) {
e.e = event_init(EVT_PROP_CHANGED, obj);
emitter_dispatch((emitter_t*)obj, (event_t*)(&e));
}
}
return ret;
}
ret_t tk_object_set_prop_str(tk_object_t* obj, const char* name, const char* value) {
value_t v;
value_set_str(&v, value);
return tk_object_set_prop(obj, name, &v);
}
ret_t tk_object_set_prop_pointer(tk_object_t* obj, const char* name, void* value) {
return tk_object_set_prop_pointer_ex(obj, name, value, NULL);
}
ret_t tk_object_set_prop_pointer_ex(tk_object_t* obj, const char* name, void* value,
tk_destroy_t destroy) {
value_t v;
ret_t ret = RET_OK;
value_set_int(&v, 0);
ret = tk_object_set_prop(obj, name, value_set_pointer_ex(&v, value, destroy));
value_reset(&v);
return ret;
}
ret_t tk_object_set_prop_object(tk_object_t* obj, const char* name, tk_object_t* value) {
value_t v;
return tk_object_set_prop(obj, name, value_set_object(&v, value));
}
ret_t tk_object_set_prop_int(tk_object_t* obj, const char* name, int32_t value) {
value_t v;
value_set_int(&v, value);
return tk_object_set_prop(obj, name, &v);
}
ret_t tk_object_set_prop_bool(tk_object_t* obj, const char* name, bool_t value) {
value_t v;
value_set_bool(&v, value);
return tk_object_set_prop(obj, name, &v);
}
ret_t tk_object_set_prop_float(tk_object_t* obj, const char* name, float_t value) {
value_t v;
value_set_float(&v, value);
return tk_object_set_prop(obj, name, &v);
}
ret_t tk_object_set_prop_double(tk_object_t* obj, const char* name, double value) {
value_t v;
value_set_double(&v, value);
return tk_object_set_prop(obj, name, &v);
}
ret_t tk_object_remove_prop(tk_object_t* obj, const char* name) {
ret_t ret = RET_NOT_FOUND;
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, RET_BAD_PARAMS);
return_value_if_fail(!(obj->visiting), RET_BUSY);
if (obj->vt->remove_prop != NULL) {
ret = obj->vt->remove_prop(obj, name);
}
return ret;
}
ret_t tk_object_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
ret_t ret = RET_NOT_IMPL;
return_value_if_fail(on_prop != NULL, RET_BAD_PARAMS);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, RET_BAD_PARAMS);
return_value_if_fail(!(obj->visiting), RET_BUSY);
if (obj->vt->foreach_prop != NULL) {
obj->visiting = TRUE;
ret = obj->vt->foreach_prop(obj, on_prop, ctx);
obj->visiting = FALSE;
}
return ret;
}
int tk_object_compare(tk_object_t* obj, tk_object_t* other) {
int32_t ret = -1;
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, -1);
return_value_if_fail(other != NULL && other->vt != NULL && other->ref_count >= 0, -1);
if (obj->vt->compare != NULL) {
ret = obj->vt->compare(obj, other);
}
return ret;
}
bool_t tk_object_can_exec(tk_object_t* obj, const char* name, const char* args) {
bool_t ret = FALSE;
cmd_exec_event_t e;
return_value_if_fail(name != NULL, FALSE);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, FALSE);
if (emitter_dispatch(EMITTER(obj), cmd_exec_event_init(&e, EVT_CMD_CAN_EXEC, name, args)) !=
RET_OK) {
return e.can_exec;
}
if (obj->vt->can_exec != NULL) {
ret = obj->vt->can_exec(obj, name, args);
}
return ret;
}
ret_t tk_object_exec(tk_object_t* obj, const char* name, const char* args) {
cmd_exec_event_t e;
event_t* evt = NULL;
ret_t ret = RET_NOT_IMPL;
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, RET_BAD_PARAMS);
if (emitter_dispatch(EMITTER(obj), cmd_exec_event_init(&e, EVT_CMD_WILL_EXEC, name, args)) !=
RET_OK) {
return RET_FAIL;
}
if (obj->vt->exec != NULL) {
ret = obj->vt->exec(obj, name, args);
}
evt = cmd_exec_event_init(&e, EVT_CMD_EXECED, name, args);
e.result = ret;
emitter_dispatch(EMITTER(obj), evt);
return e.result;
}
bool_t tk_object_has_prop(tk_object_t* obj, const char* name) {
value_t v;
ret_t ret = RET_OK;
ret = tk_object_get_prop(obj, name, &v);
if (ret == RET_OK) {
value_reset(&v);
}
return ret == RET_OK;
}
ret_t tk_object_copy_prop(tk_object_t* obj, tk_object_t* src, const char* name) {
value_t v;
ret_t ret = RET_FAIL;
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, RET_BAD_PARAMS);
return_value_if_fail(src != NULL && src->vt != NULL && src->ref_count >= 0, RET_BAD_PARAMS);
if (tk_object_get_prop(src, name, &v) == RET_OK) {
ret = tk_object_set_prop(obj, name, &v);
value_reset(&v);
}
return ret;
}
typedef struct _copy_ctx_t {
bool_t overwrite;
tk_object_t* dst;
} copy_ctx_t;
static ret_t on_copy_on_prop(void* ctx, const void* data) {
named_value_t* nv = (named_value_t*)data;
copy_ctx_t* info = (copy_ctx_t*)ctx;
if (info->overwrite) {
tk_object_set_prop(info->dst, nv->name, &(nv->value));
} else {
value_t v;
if (tk_object_get_prop(info->dst, nv->name, &v) != RET_OK) {
tk_object_set_prop(info->dst, nv->name, &(nv->value));
}
}
return RET_OK;
}
ret_t tk_object_copy_props(tk_object_t* obj, tk_object_t* src, bool_t overwrite) {
copy_ctx_t ctx = {overwrite, obj};
return_value_if_fail(obj != NULL && src != NULL, RET_BAD_PARAMS);
return tk_object_foreach_prop(src, on_copy_on_prop, &ctx);
}
#ifndef WITHOUT_FSCRIPT
ret_t tk_object_eval(tk_object_t* obj, const char* expr, value_t* v) {
return fscript_eval(obj, expr, v);
}
#else
ret_t tk_object_eval(tk_object_t* obj, const char* expr, value_t* v) {
return_value_if_fail(expr != NULL && v != NULL, RET_BAD_PARAMS);
return_value_if_fail(obj != NULL && obj->vt != NULL && obj->ref_count >= 0, RET_BAD_PARAMS);
if (tk_is_valid_name(expr)) {
return tk_object_get_prop(obj, expr, v);
} else {
return RET_FAIL;
}
}
#endif /*WITHOUT_FSCRIPT*/
const char* tk_object_get_type(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL, NULL);
return obj->vt->type;
}
const char* tk_object_get_desc(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL, NULL);
return obj->vt->desc;
}
bool_t tk_object_is_collection(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL, FALSE);
return obj->vt->is_collection;
}
uint32_t tk_object_get_size(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt != NULL, 0);
return obj->vt->size;
}
bool_t tk_object_has_prop_by_path(tk_object_t* obj, const char* path) {
value_t v;
ret_t ret = RET_OK;
ret = tk_object_get_prop_by_path(obj, path, &v);
if (ret == RET_OK) {
value_reset(&v);
}
return ret == RET_OK;
}
const char* tk_object_get_prop_str_by_path(tk_object_t* obj, const char* path) {
value_t v;
if (tk_object_get_prop_by_path(obj, path, &v) == RET_OK) {
return value_str(&v);
} else {
return NULL;
}
}
void* tk_object_get_prop_pointer_by_path(tk_object_t* obj, const char* path) {
value_t v;
if (tk_object_get_prop_by_path(obj, path, &v) == RET_OK) {
return value_pointer(&v);
} else {
return NULL;
}
}
tk_object_t* tk_object_get_prop_object_by_path(tk_object_t* obj, const char* path) {
value_t v;
if (tk_object_get_prop_by_path(obj, path, &v) == RET_OK) {
return value_object(&v);
} else {
return NULL;
}
}
int32_t tk_object_get_prop_int_by_path(tk_object_t* obj, const char* path, int32_t defval) {
value_t v;
if (tk_object_get_prop_by_path(obj, path, &v) == RET_OK) {
return value_int(&v);
} else {
return defval;
}
}
bool_t tk_object_get_prop_bool_by_path(tk_object_t* obj, const char* path, bool_t defval) {
value_t v;
if (tk_object_get_prop_by_path(obj, path, &v) == RET_OK) {
return value_bool(&v);
} else {
return defval;
}
}
float_t tk_object_get_prop_float_by_path(tk_object_t* obj, const char* path, float_t defval) {
value_t v;
if (tk_object_get_prop_by_path(obj, path, &v) == RET_OK) {
return value_float(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_by_path(tk_object_t* obj, const char* path, const value_t* value) {
const char* name;
return_value_if_fail(path != NULL, RET_BAD_PARAMS);
name = path + strlen(path);
while (path <= --name) {
if (name[0] == '.') break;
}
name++;
if (name == path) {
return tk_object_set_prop(obj, name, value);
} else {
ret_t ret = RET_OK;
value_t v;
uint32_t len = name - path - 1;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
return_value_if_fail(value != NULL, RET_BAD_PARAMS);
ret = object_get_prop_by_path_with_len(obj, path, len, &v);
if (ret != RET_OK) {
return ret;
}
return tk_object_set_prop(value_object(&v), name, value);
}
}
ret_t tk_object_set_prop_str_by_path(tk_object_t* obj, const char* name, const char* value) {
value_t v;
value_set_str(&v, value);
return tk_object_set_prop_by_path(obj, name, &v);
}
ret_t tk_object_set_prop_pointer_by_path(tk_object_t* obj, const char* name, void* value) {
value_t v;
value_set_pointer(&v, value);
return tk_object_set_prop_by_path(obj, name, &v);
}
ret_t tk_object_set_prop_object_by_path(tk_object_t* obj, const char* name, tk_object_t* value) {
value_t v;
value_set_object(&v, value);
return tk_object_set_prop_by_path(obj, name, &v);
}
ret_t tk_object_set_prop_int_by_path(tk_object_t* obj, const char* name, int32_t value) {
value_t v;
value_set_int(&v, value);
return tk_object_set_prop_by_path(obj, name, &v);
}
ret_t tk_object_set_prop_bool_by_path(tk_object_t* obj, const char* name, bool_t value) {
value_t v;
value_set_bool(&v, value);
return tk_object_set_prop_by_path(obj, name, &v);
}
ret_t tk_object_set_prop_float_by_path(tk_object_t* obj, const char* name, float_t value) {
value_t v;
value_set_float(&v, value);
return tk_object_set_prop_by_path(obj, name, &v);
}
bool_t tk_object_can_exec_by_path(tk_object_t* obj, const char* path, const char* args) {
const char* name;
return_value_if_fail(path != NULL, FALSE);
name = path + strlen(path);
while (path <= --name) {
if (name[0] == '.') break;
}
name++;
if (name == path) {
return tk_object_can_exec(obj, name, args);
} else {
value_t v;
uint32_t len = name - path - 1;
return_value_if_fail(obj != NULL && obj->vt != NULL, FALSE);
if (object_get_prop_by_path_with_len(obj, path, len, &v) != RET_OK) {
return FALSE;
}
return tk_object_can_exec(value_object(&v), name, args);
}
}
ret_t tk_object_exec_by_path(tk_object_t* obj, const char* path, const char* args) {
const char* name;
return_value_if_fail(path != NULL, RET_BAD_PARAMS);
name = path + strlen(path);
while (path <= --name) {
if (name[0] == '.') break;
}
name++;
if (name == path) {
return tk_object_exec(obj, name, args);
} else {
ret_t ret = RET_OK;
value_t v;
uint32_t len = name - path - 1;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
ret = object_get_prop_by_path_with_len(obj, path, len, &v);
if (ret != RET_OK) {
return ret;
}
return tk_object_exec(value_object(&v), name, args);
}
}
ret_t tk_object_set_prop_int8(tk_object_t* obj, const char* name, int8_t value) {
value_t v;
value_set_int8(&v, value);
return tk_object_set_prop(obj, name, &v);
}
int8_t tk_object_get_prop_int8(tk_object_t* obj, const char* name, int8_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_int8(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_uint8(tk_object_t* obj, const char* name, uint8_t value) {
value_t v;
value_set_uint8(&v, value);
return tk_object_set_prop(obj, name, &v);
}
uint8_t tk_object_get_prop_uint8(tk_object_t* obj, const char* name, uint8_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_uint8(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_int16(tk_object_t* obj, const char* name, int16_t value) {
value_t v;
value_set_int16(&v, value);
return tk_object_set_prop(obj, name, &v);
}
int16_t tk_object_get_prop_int16(tk_object_t* obj, const char* name, int16_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_int16(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_uint16(tk_object_t* obj, const char* name, uint16_t value) {
value_t v;
value_set_uint16(&v, value);
return tk_object_set_prop(obj, name, &v);
}
uint16_t tk_object_get_prop_uint16(tk_object_t* obj, const char* name, uint16_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_uint16(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_int32(tk_object_t* obj, const char* name, int32_t value) {
value_t v;
value_set_int32(&v, value);
return tk_object_set_prop(obj, name, &v);
}
int32_t tk_object_get_prop_int32(tk_object_t* obj, const char* name, int32_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_int32(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_uint32(tk_object_t* obj, const char* name, uint32_t value) {
value_t v;
value_set_uint32(&v, value);
return tk_object_set_prop(obj, name, &v);
}
uint32_t tk_object_get_prop_uint32(tk_object_t* obj, const char* name, uint32_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_uint32(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_int64(tk_object_t* obj, const char* name, int64_t value) {
value_t v;
value_set_int64(&v, value);
return tk_object_set_prop(obj, name, &v);
}
int64_t tk_object_get_prop_int64(tk_object_t* obj, const char* name, int64_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_int64(&v);
} else {
return defval;
}
}
ret_t tk_object_set_prop_uint64(tk_object_t* obj, const char* name, uint64_t value) {
value_t v;
value_set_uint64(&v, value);
return tk_object_set_prop(obj, name, &v);
}
uint64_t tk_object_get_prop_uint64(tk_object_t* obj, const char* name, uint64_t defval) {
value_t v;
if (tk_object_get_prop(obj, name, &v) == RET_OK) {
return value_uint64(&v);
} else {
return defval;
}
}
ret_t tk_object_clear_props(tk_object_t* obj) {
ret_t ret = RET_NOT_IMPL;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
if (obj->vt->clear_props != NULL) {
ret = obj->vt->clear_props(obj);
}
return ret;
}
typedef struct _find_prop_default_ctx_t {
tk_compare_t cmp;
void* data;
value_t* value;
} find_prop_default_ctx_t;
static ret_t tk_object_find_prop_default_on_visit(void* ctx, const void* data) {
const named_value_t* nv = (const named_value_t*)data;
find_prop_default_ctx_t* actx = (find_prop_default_ctx_t*)(ctx);
if (0 == actx->cmp(data, actx->data)) {
actx->value = (value_t*)&nv->value;
return RET_FOUND;
}
return RET_OK;
}
static value_t* tk_object_find_prop_default(tk_object_t* obj, tk_compare_t cmp, const void* data) {
find_prop_default_ctx_t actx;
actx.cmp = cmp;
actx.data = data;
actx.value = NULL;
if (RET_FOUND == tk_object_foreach_prop(obj, tk_object_find_prop_default_on_visit, &actx)) {
return actx.value;
}
return NULL;
}
value_t* tk_object_find_prop(tk_object_t* obj, tk_compare_t cmp, const void* data) {
value_t* ret = NULL;
return_value_if_fail(obj != NULL && obj->vt != NULL, NULL);
return_value_if_fail(cmp != NULL, NULL);
if (obj->vt->find_prop != NULL) {
ret = obj->vt->find_prop(obj, cmp, data);
} else {
ret = tk_object_find_prop_default(obj, cmp, data);
}
return ret;
}
typedef struct _find_props_default_ctx_t {
tk_compare_t cmp;
void* data;
darray_t* matched;
} find_props_default_ctx_t;
static ret_t tk_object_find_props_default_on_visit(void* ctx, const void* data) {
const named_value_t* nv = (const named_value_t*)data;
find_props_default_ctx_t* actx = (find_props_default_ctx_t*)(ctx);
if (0 == actx->cmp(data, actx->data)) {
return darray_push(actx->matched, (value_t*)&nv->value);
}
return RET_OK;
}
static ret_t tk_object_find_props_default(tk_object_t* obj, tk_compare_t cmp, const void* data,
darray_t* matched) {
find_props_default_ctx_t actx;
actx.cmp = cmp;
actx.data = data;
actx.matched = matched;
return tk_object_foreach_prop(obj, tk_object_find_props_default_on_visit, &actx);
}
ret_t tk_object_find_props(tk_object_t* obj, tk_compare_t cmp, const void* data,
darray_t* matched) {
ret_t ret = RET_OK;
return_value_if_fail(obj != NULL && obj->vt != NULL, RET_BAD_PARAMS);
return_value_if_fail(cmp != NULL && matched != NULL, RET_BAD_PARAMS);
if (obj->vt->find_props != NULL) {
ret = obj->vt->find_props(obj, cmp, data, matched);
} else {
ret = tk_object_find_props_default(obj, cmp, data, matched);
}
return ret;
}
tk_object_t* tk_object_get_child_object(tk_object_t* obj, const char* path,
const char** next_path) {
return_value_if_fail(obj != NULL && path != NULL && next_path != NULL, NULL);
const char* p = strchr(path, '.');
if (p != NULL) {
value_t v;
uint32_t len = p - path;
char subname[TK_OBJECT_PROP_NAME_MAX_LEN] = {0};
uint32_t size = tk_min(TK_OBJECT_PROP_NAME_MAX_LEN - 1, len);
return_value_if_fail(len < TK_OBJECT_PROP_NAME_MAX_LEN - 1, NULL);
tk_memcpy(subname, path, size);
subname[size] = '\0';
if (tk_object_get_prop(obj, subname, &v) == RET_OK) {
if (v.type == VALUE_TYPE_OBJECT) {
*next_path = p + 1;
return value_object(&v);
}
}
}
return NULL;
}
typedef struct _json_info_t {
str_t* json;
uint32_t indent;
uint32_t level;
bool_t oneline;
uint32_t index;
bool_t is_array;
} json_info_t;
static ret_t to_json(void* ctx, const void* data) {
char buff[64] = {0};
json_info_t* info = (json_info_t*)ctx;
named_value_t* nv = (named_value_t*)data;
str_t* s = info->json;
value_t* v = &(nv->value);
bool_t oneline = info->oneline;
if (info->index > 0) {
str_append(s, ",");
}
if (!oneline) {
str_append(s, "\n");
}
info->index++;
if (!oneline) {
str_append_n_chars(s, ' ', info->indent * info->level);
}
if (!info->is_array) {
str_append_json_str(s, nv->name);
str_append(s, ": ");
}
switch (v->type) {
case VALUE_TYPE_STRING: {
str_append_json_str(s, value_str(v));
break;
}
case VALUE_TYPE_OBJECT: {
tk_object_to_json(value_object(v), s, info->indent + 1, info->level, oneline);
break;
}
case VALUE_TYPE_INT8:
case VALUE_TYPE_BOOL:
case VALUE_TYPE_INT16:
case VALUE_TYPE_INT32:
case VALUE_TYPE_INT64:
case VALUE_TYPE_UINT8:
case VALUE_TYPE_UINT16:
case VALUE_TYPE_UINT32:
case VALUE_TYPE_UINT64:
case VALUE_TYPE_FLOAT:
case VALUE_TYPE_FLOAT32:
case VALUE_TYPE_DOUBLE: {
str_append(s, value_str_ex(v, buff, sizeof(buff)));
break;
}
default: {
str_append_json_str(s, value_str_ex(v, buff, sizeof(buff)));
break;
}
}
return RET_OK;
}
ret_t tk_object_to_json(tk_object_t* obj, str_t* json, uint32_t indent, uint32_t level,
bool_t oneline) {
bool_t is_array = FALSE;
json_info_t info = {json, indent, level, oneline, 0};
return_value_if_fail(obj != NULL && json != NULL, RET_BAD_PARAMS);
if (!oneline) {
str_append_n_chars(json, ' ', indent * level);
}
is_array = tk_str_eq(obj->vt->type, "object_array");
info.is_array = is_array;
str_append(json, is_array ? "[" : "{");
info.level++;
tk_object_foreach_prop(obj, to_json, &info);
if (!oneline) {
str_append(json, "\n");
}
if (!oneline) {
str_append_n_chars(json, ' ', indent * level);
}
str_append(json, is_array ? "]" : "}");
return RET_OK;
}
ret_t tk_object_set_prop_str_with_format(tk_object_t* obj, const char* name, const char* format,
...) {
char str[256] = {0};
return_value_if_fail(obj != NULL && name != NULL && format != NULL, RET_BAD_PARAMS);
va_list args;
va_start(args, format);
vsnprintf(str, sizeof(str) - 1, format, args);
va_end(args);
return tk_object_set_prop_str(obj, name, str);
}
bool_t tk_object_is_instance_of(tk_object_t* obj, const char* type) {
return_value_if_fail(obj != NULL && obj->vt != NULL, FALSE);
return tk_str_eq(obj->vt->type, type);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/istream.h
|
/**
* File: tk_istream.h
* Author: AWTK Develop Team
* Brief: input stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ISTREAM_H
#define TK_ISTREAM_H
#include "tkc/str.h"
#include "tkc/object.h"
#include "tkc/stream_const.h"
BEGIN_C_DECLS
struct _tk_istream_t;
typedef struct _tk_istream_t tk_istream_t;
typedef int32_t (*tk_istream_read_t)(tk_istream_t* stream, uint8_t* buff, uint32_t max_size);
typedef ret_t (*tk_istream_flush_t)(tk_istream_t* stream);
typedef ret_t (*tk_istream_seek_t)(tk_istream_t* stream, uint32_t offset);
typedef int32_t (*tk_istream_tell_t)(tk_istream_t* stream);
typedef bool_t (*tk_istream_eos_t)(tk_istream_t* stream);
typedef ret_t (*tk_istream_wait_for_data_t)(tk_istream_t* stream, uint32_t timeout_ms);
/**
* @class tk_istream_t
* @parent tk_object_t
*
* 输入流的接口。
*
*/
struct _tk_istream_t {
tk_object_t object;
tk_istream_eos_t eos;
tk_istream_read_t read;
tk_istream_tell_t tell;
tk_istream_seek_t seek;
tk_istream_flush_t flush;
tk_istream_wait_for_data_t wait_for_data;
};
/**
* @method tk_istream_read
*
* 读取数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
*
* @return {int32_t} 返回负数表示读取失败，否则返回实际读取数据的长度。
*
*/
int32_t tk_istream_read(tk_istream_t* stream, void* buff, uint32_t max_size);
/**
* @method tk_istream_seek
*
* 设置偏移量。
*
* @param {tk_istream_t*} stream istream对象。
* @param {uint32_t} offset 偏移量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_seek(tk_istream_t* stream, uint32_t offset);
/**
* @method tk_istream_tell
*
* 获取当前读取位置。
*
* @param {tk_istream_t*} stream istream对象。
*
* @return {int32_t} 返回负数表示失败，否则返回当前读取位置。
*
*/
int32_t tk_istream_tell(tk_istream_t* stream);
/**
* @method tk_istream_eos
*
* 判断数据是否读完。
*
* @param {tk_istream_t*} stream istream对象。
*
* @return {bool_t} 返回TRUE表示数据读完，否则表示还有数据。
*
*/
bool_t tk_istream_eos(tk_istream_t* stream);
/**
* @method tk_istream_wait_for_data
*
* 等待数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {uint32_t} timeout_ms 超时时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_wait_for_data(tk_istream_t* stream, uint32_t timeout_ms);
/**
* @method tk_istream_flush
*
* 刷新数据。
*
* @param {tk_istream_t*} stream istream对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_flush(tk_istream_t* stream);
/**
* @method tk_istream_read_uint8
*
* 写入uint8数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {uint8_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_uint8(tk_istream_t* stream, uint8_t* value);
/**
* @method tk_istream_read_uint16
*
* 写入uint16数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {uint16_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_uint16(tk_istream_t* stream, uint16_t* value);
/**
* @method tk_istream_read_uint32
*
* 写入uint32数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {uint32_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_uint32(tk_istream_t* stream, uint32_t* value);
/**
* @method tk_istream_read_uint64
*
* 写入uint64数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {uint64_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_uint64(tk_istream_t* stream, uint64_t* value);
/**
* @method tk_istream_read_int8
*
* 写入int8数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {int8_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_int8(tk_istream_t* stream, int8_t* value);
/**
* @method tk_istream_read_int16
*
* 写入int16数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {int16_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_int16(tk_istream_t* stream, int16_t* value);
/**
* @method tk_istream_read_int32
*
* 写入int32数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {int32_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_int32(tk_istream_t* stream, int32_t* value);
/**
* @method tk_istream_read_int64
*
* 写入int64数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {int64_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_int64(tk_istream_t* stream, int64_t* value);
/**
* @method tk_istream_read_float
*
* 写入float数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {float*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_float(tk_istream_t* stream, float* value);
/**
* @method tk_istream_read_double
*
* 写入double数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {double*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_double(tk_istream_t* stream, double* value);
/**
* @method tk_istream_read_len
*
* 读取指定长度的数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
* @param {uint32_t} timeout_ms timeout.
*
* @return {int32_t} 返回负数表示读取失败，否则返回实际读取数据的长度。
*
*/
int32_t tk_istream_read_len(tk_istream_t* stream, void* buff, uint32_t max_size,
uint32_t timeout_ms);
/**
* @method tk_istream_read_line
*
* 读取一行数据。
*
* @param {tk_istream_t*} stream istream对象。
* @param {void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
* @param {uint32_t} timeout_ms timeout.
*
* @return {int32_t} 返回负数表示读取失败，否则返回实际读取数据的长度。
*
*/
int32_t tk_istream_read_line(tk_istream_t* stream, void* buff, uint32_t max_size,
uint32_t timeout_ms);
/**
* @method tk_istream_read_line_str
*
* 读取一行数据。
* >istream必须支持随机读写(seek/tell)。
*
* @param {tk_istream_t*} stream istream对象。
* @param {str_t*} str 返回数据的str对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t tk_istream_read_line_str(tk_istream_t* stream, str_t* str);
/**
* @method tk_istream_unref
*
* 引用计数减1。引用计数为0时，销毁对象。
* @param {tk_istream_t*} stream istream对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_istream_unref(tk_istream_t* stream);
#define TK_ISTREAM(obj) ((tk_istream_t*)(obj))
#define TK_ISTREAM_SEEKABLE(obj) (TK_ISTREAM(obj)->seek != NULL)
#define TK_ISTREAM_TELLABLE(obj) (TK_ISTREAM(obj)->tell != NULL)
END_C_DECLS
#endif /*TK_ISTREAM_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_fd.c
|
/**
* File: event_source_fd.h
* Author: AWTK Develop Team
* Brief: event source fd
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#include "tkc/event_source_fd.h"
static const object_vtable_t s_event_source_fd_vtable = {
.type = "event_source_fd", .desc = "event_source_fd", .size = sizeof(event_source_fd_t)};
static int32_t event_source_fd_get_fd(event_source_t* source) {
event_source_fd_t* event_source_fd = EVENT_SOURCE_FD(source);
return event_source_fd->fd;
}
static ret_t event_source_fd_check(event_source_t* source) {
return RET_OK;
}
static ret_t event_source_fd_dispatch(event_source_t* source) {
event_source_fd_t* event_source_fd = EVENT_SOURCE_FD(source);
return event_source_fd->on_event(source);
}
uint32_t event_source_fd_get_wakeup_time(event_source_t* source) {
return 0xffff;
}
event_source_t* event_source_fd_create(int fd, event_source_on_event_t on_event, void* ctx) {
tk_object_t* obj = NULL;
event_source_t* event_source = NULL;
event_source_fd_t* event_source_fd = NULL;
return_value_if_fail(fd >= 0 && on_event != NULL, NULL);
obj = tk_object_create(&s_event_source_fd_vtable);
event_source = EVENT_SOURCE(obj);
event_source_fd = EVENT_SOURCE_FD(obj);
return_value_if_fail(event_source_fd != NULL, NULL);
event_source_fd->fd = fd;
event_source_fd->ctx = ctx;
event_source_fd->on_event = on_event;
event_source->check = event_source_fd_check;
event_source->get_fd = event_source_fd_get_fd;
event_source->dispatch = event_source_fd_dispatch;
event_source->get_wakeup_time = event_source_fd_get_wakeup_time;
return event_source;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/fs.c
|
/**
* File: fs.h
* Author: AWTK Develop Team
* Brief: simple fs api
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-27 Li XianJing <[email protected]> created
*
*/
#include "tkc/fs.h"
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/path.h"
fs_stat_info_t* fs_stat_info_create(void) {
fs_stat_info_t* ret = TKMEM_ZALLOC(fs_stat_info_t);
return_value_if_fail(ret != NULL, NULL);
return ret;
}
ret_t fs_stat_info_destroy(fs_stat_info_t* fst) {
return_value_if_fail(fst != NULL, RET_BAD_PARAMS);
TKMEM_FREE(fst);
return RET_OK;
}
fs_item_t* fs_item_create(void) {
fs_item_t* ret = TKMEM_ZALLOC(fs_item_t);
return_value_if_fail(ret != NULL, NULL);
return ret;
}
ret_t fs_item_destroy(fs_item_t* item) {
return_value_if_fail(item != NULL, RET_BAD_PARAMS);
TKMEM_FREE(item);
return RET_OK;
}
int32_t fs_file_read(fs_file_t* file, void* buffer, uint32_t size) {
return_value_if_fail(file != NULL && file->vt != NULL && buffer != NULL && file->vt->read != NULL,
-1);
return file->vt->read(file, buffer, size);
}
int32_t fs_file_write(fs_file_t* file, const void* buffer, uint32_t size) {
return_value_if_fail(
file != NULL && file->vt != NULL && buffer != NULL && file->vt->write != NULL, -1);
return file->vt->write(file, buffer, size);
}
int32_t fs_file_printf(fs_file_t* file, const char* const format_str, ...) {
va_list v_l;
int32_t ret = 0;
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->printf != NULL, -1);
va_start(v_l, format_str);
ret = file->vt->printf(file, format_str, v_l);
va_end(v_l);
return ret;
}
ret_t fs_file_seek(fs_file_t* file, int32_t offset) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->seek != NULL, RET_BAD_PARAMS);
return file->vt->seek(file, offset);
}
ret_t fs_file_truncate(fs_file_t* file, int32_t offset) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->truncate != NULL,
RET_BAD_PARAMS);
fs_file_seek(file, 0);
return file->vt->truncate(file, offset);
}
bool_t fs_file_eof(fs_file_t* file) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->eof != NULL, TRUE);
return file->vt->eof(file);
}
int64_t fs_file_tell(fs_file_t* file) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->tell != NULL, -1);
return file->vt->tell(file);
}
int64_t fs_file_size(fs_file_t* file) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->size != NULL, -1);
return file->vt->size(file);
}
ret_t fs_file_close(fs_file_t* file) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->close != NULL, RET_BAD_PARAMS);
return file->vt->close(file);
}
ret_t fs_file_sync(fs_file_t* file) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->sync != NULL, RET_BAD_PARAMS);
return file->vt->sync(file);
}
ret_t fs_file_stat(fs_file_t* file, fs_stat_info_t* fst) {
return_value_if_fail(file != NULL && file->vt != NULL && file->vt->stat != NULL && fst != NULL,
RET_BAD_PARAMS);
return file->vt->stat(file, fst);
}
ret_t fs_dir_rewind(fs_dir_t* dir) {
return_value_if_fail(dir != NULL && dir->vt != NULL && dir->vt->rewind != NULL, RET_BAD_PARAMS);
return dir->vt->rewind(dir);
}
ret_t fs_dir_read(fs_dir_t* dir, fs_item_t* item) {
return_value_if_fail(dir != NULL && dir->vt != NULL && dir->vt->read != NULL && item != NULL,
RET_BAD_PARAMS);
return dir->vt->read(dir, item);
}
ret_t fs_dir_close(fs_dir_t* dir) {
return_value_if_fail(dir != NULL && dir->vt != NULL && dir->vt->close != NULL, RET_BAD_PARAMS);
return dir->vt->close(dir);
}
fs_file_t* fs_open_file(fs_t* fs, const char* name, const char* mode) {
return_value_if_fail(fs != NULL && name != NULL && mode != NULL, NULL);
return fs->open_file(fs, name, mode);
}
ret_t fs_remove_file(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->remove_file != NULL && name != NULL, RET_BAD_PARAMS);
return fs->remove_file(fs, name);
}
bool_t fs_file_exist(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->file_exist != NULL && name != NULL, FALSE);
return fs->file_exist(fs, name);
}
ret_t fs_file_rename(fs_t* fs, const char* name, const char* new_name) {
return_value_if_fail(fs != NULL && fs->file_rename != NULL && name != NULL && new_name != NULL,
RET_BAD_PARAMS);
return fs->file_rename(fs, name, new_name);
}
fs_dir_t* fs_open_dir(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->open_dir != NULL && name != NULL, NULL);
return fs->open_dir(fs, name);
}
ret_t fs_remove_dir(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->remove_dir != NULL && name != NULL, RET_BAD_PARAMS);
return fs->remove_dir(fs, name);
}
ret_t fs_change_dir(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->change_dir != NULL && name != NULL, RET_BAD_PARAMS);
return fs->change_dir(fs, name);
}
ret_t fs_create_dir(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->create_dir != NULL && name != NULL, RET_BAD_PARAMS);
return fs->create_dir(fs, name);
}
bool_t fs_dir_exist(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->dir_exist != NULL && name != NULL, FALSE);
return fs->dir_exist(fs, name);
}
ret_t fs_dir_rename(fs_t* fs, const char* name, const char* new_name) {
return_value_if_fail(fs != NULL && fs->dir_rename != NULL && name != NULL && new_name,
RET_BAD_PARAMS);
return fs->dir_rename(fs, name, new_name);
}
int32_t fs_get_file_size(fs_t* fs, const char* name) {
return_value_if_fail(fs != NULL && fs->get_file_size != NULL && name != NULL, -1);
return fs->get_file_size(fs, name);
}
ret_t fs_get_disk_info(fs_t* fs, const char* volume, int32_t* free_kb, int32_t* total_kb) {
return_value_if_fail(fs != NULL && free_kb != NULL && total_kb != NULL, RET_BAD_PARAMS);
return fs->get_disk_info(fs, volume, free_kb, total_kb);
}
ret_t fs_get_exe(fs_t* fs, char path[MAX_PATH + 1]) {
return_value_if_fail(fs != NULL && fs->get_exe != NULL && path != NULL, RET_BAD_PARAMS);
return fs->get_exe(fs, path);
}
ret_t fs_get_user_storage_path(fs_t* fs, char path[MAX_PATH + 1]) {
return_value_if_fail(fs != NULL && fs->get_user_storage_path != NULL && path != NULL,
RET_BAD_PARAMS);
return fs->get_user_storage_path(fs, path);
}
ret_t fs_get_temp_path(fs_t* fs, char path[MAX_PATH + 1]) {
return_value_if_fail(fs != NULL && fs->get_temp_path != NULL && path != NULL, RET_BAD_PARAMS);
return fs->get_temp_path(fs, path);
}
ret_t fs_get_cwd(fs_t* fs, char path[MAX_PATH + 1]) {
return_value_if_fail(fs != NULL && fs->get_cwd != NULL && path != NULL, RET_BAD_PARAMS);
return fs->get_cwd(fs, path);
}
int32_t file_get_size(const char* name) {
return fs_get_file_size(os_fs(), name);
}
ret_t fs_stat(fs_t* fs, const char* name, fs_stat_info_t* fst) {
return_value_if_fail(fs != NULL && fs->stat != NULL && name != NULL, RET_BAD_PARAMS);
return fs->stat(fs, name, fst);
}
int32_t file_read_part(const char* name, void* buff, uint32_t size, uint32_t offset) {
int32_t ret = 0;
fs_file_t* fp = NULL;
return_value_if_fail(name != NULL && buff != NULL, -1);
fp = fs_open_file(os_fs(), name, "rb");
if (fp != NULL) {
if (fs_file_seek(fp, offset) == RET_OK) {
ret = fs_file_read(fp, buff, size);
}
fs_file_close(fp);
}
return ret;
}
void* file_read(const char* name, uint32_t* size) {
uint8_t* buff = NULL;
int32_t len = file_get_size(name);
return_value_if_fail(name != NULL && len > 0, NULL);
buff = (uint8_t*)TKMEM_ALLOC(len + 1);
return_value_if_fail(buff != NULL, NULL);
if (file_read_part(name, buff, len, 0) == len) {
if (size != NULL) {
*size = len;
}
buff[len] = '\0';
return buff;
} else {
if (size != NULL) {
*size = 0;
}
TKMEM_FREE(buff);
return NULL;
}
}
ret_t file_write(const char* name, const void* buff, uint32_t size) {
ret_t ret = RET_OK;
fs_file_t* fp = NULL;
return_value_if_fail(name != NULL && buff != NULL, RET_BAD_PARAMS);
fp = fs_open_file(os_fs(), name, "wb+");
return_value_if_fail(fp != NULL, RET_FAIL);
if (fs_file_write(fp, buff, size) != size) {
ret = RET_FAIL;
}
fs_file_close(fp);
return ret;
}
ret_t file_remove(const char* name) {
return_value_if_fail(name != NULL, RET_BAD_PARAMS);
return fs_remove_file(os_fs(), name);
}
bool_t file_exist(const char* name) {
return_value_if_fail(name != NULL, FALSE);
return fs_file_exist(os_fs(), name);
}
bool_t dir_exist(const char* name) {
return_value_if_fail(name != NULL, FALSE);
return fs_dir_exist(os_fs(), name);
}
ret_t fs_test_file(fs_t* fs) {
char buff[32];
fs_file_t* fp = NULL;
const char* filename = "./test.txt";
char path[MAX_PATH + 1] = {0};
assert(fs_get_cwd(os_fs(), path) == RET_OK);
assert(fs_get_exe(os_fs(), path) == RET_OK);
assert(fs_get_temp_path(os_fs(), path) == RET_OK);
assert(fs_get_user_storage_path(os_fs(), path) == RET_OK);
memset(buff, 0x00, sizeof(buff));
fp = fs_open_file(fs, filename, "w+");
assert(fs_file_write(fp, "hello", 5) == 5);
assert(fs_file_tell(fp) == 5);
assert(fs_file_sync(fp) == RET_OK);
assert(fs_file_size(fp) == 5);
assert(fs_file_truncate(fp, 0) == RET_OK);
assert(fs_file_write(fp, "world", 5) == 5);
assert(fs_file_seek(fp, 0) == RET_OK);
assert(fs_file_write(fp, "WORLD", 5) == 5);
assert(fs_file_close(fp) == RET_OK);
assert(fs_file_exist(fs, filename) == TRUE);
fp = fs_open_file(fs, filename, "a");
assert(fs_file_write(fp, "world", 5) == 5);
assert(fs_file_close(fp) == RET_OK);
assert(fs_get_file_size(fs, filename) == 10);
fp = fs_open_file(fs, filename, "r");
assert(fs_file_read(fp, buff, 10) == 10);
assert(strcmp(buff, "WORLDworld") == 0);
assert(fs_file_close(fp) == RET_OK);
assert(fs_get_file_size(fs, filename) == 10);
fp = fs_open_file(fs, filename, "w+");
assert(fs_file_printf(fp, "%s:%d", "hello", 10) == 8);
assert(fs_file_close(fp) == RET_OK);
assert(fs_file_rename(fs, filename, "./test.bin") == RET_OK);
assert(!fs_file_exist(fs, filename));
assert(fs_file_exist(fs, "./test.bin"));
assert(fs_remove_file(fs, "./test.bin") == RET_OK);
assert(!fs_file_exist(fs, "./test.bin"));
(void)fp;
return RET_OK;
}
ret_t fs_test_dir(fs_t* fs) {
fs_item_t item;
fs_dir_t* dir = NULL;
fs_remove_dir_r(fs, "./a");
fs_remove_dir_r(fs, "./b");
assert(!fs_dir_exist(fs, "./a"));
assert(fs_create_dir(fs, "./a") == RET_OK);
assert(fs_dir_exist(fs, "./a"));
assert(fs_create_dir(fs, "./a/b") == RET_OK);
assert(fs_dir_exist(fs, "./a/b"));
assert(fs_create_dir(fs, "./a/b/c1") == RET_OK);
assert(fs_dir_exist(fs, "./a/b/c1"));
assert(fs_create_dir(fs, "./a/b/c2") == RET_OK);
assert(fs_dir_exist(fs, "./a/b/c2"));
dir = fs_open_dir(fs, "./a/b");
assert(dir != NULL);
do {
assert(fs_dir_read(dir, &item) == RET_OK);
if (item.name[0] != '.') {
break;
} else {
assert(!item.is_reg_file);
assert(item.is_dir);
}
} while (TRUE);
assert(strcmp(item.name, "c1") == 0 || strcmp(item.name, "c2") == 0);
assert(!item.is_reg_file);
assert(item.is_dir);
assert(fs_dir_read(dir, &item) == RET_OK);
assert(!item.is_reg_file);
assert(item.is_dir);
assert(fs_dir_close(dir) == RET_OK);
if (fs_dir_rename(fs, "./a/b/c2", "./a/b/c3") == RET_OK) {
assert(!fs_dir_exist(fs, "./a/b/c2"));
assert(fs_dir_exist(fs, "./a/b/c3"));
assert(fs_dir_rename(fs, "./a/b/c3", "./a/b/c2") == RET_OK);
}
assert(fs_remove_dir(fs, "./a/b/c1") == RET_OK);
assert(fs_remove_dir(fs, "./a/b/c2") == RET_OK);
assert(fs_remove_dir(fs, "./a/b") == RET_OK);
assert(fs_remove_dir(fs, "./a") == RET_OK);
(void)dir;
return RET_OK;
}
ret_t fs_test(fs_t* fs) {
fs_test_file(fs);
return fs_test_dir(fs);
}
int32_t fs_file_read_line(fs_file_t* file, char* buffer, uint32_t size) {
char tbuff[128];
char* d = buffer;
char* s = tbuff;
int32_t i = 0;
int32_t ret = 0;
int64_t offset = 0;
bool_t done = FALSE;
bool_t read_flag = FALSE;
return_value_if_fail(file != NULL && buffer != NULL && size > 1, 0);
while (((d - buffer) < size) && !done) {
offset = fs_file_tell(file);
ret = fs_file_read(file, tbuff, sizeof(tbuff) - 1);
if (ret <= 0) {
break;
}
read_flag = TRUE;
tbuff[ret] = '\0';
for (i = 0; (i < ret) && ((d - buffer) < size); i++) {
offset++;
if (s[i] == '\r') {
i++;
if (s[i] == '\n') {
offset++;
} else if (s[i] == '\0') {
char c = 0;
fs_file_read(file, &c, 1);
if (c == '\n') {
offset++;
}
}
done = TRUE;
break;
} else if (s[i] == '\n') {
done = TRUE;
break;
} else {
*d++ = s[i];
}
}
if (ret < (sizeof(tbuff) - 1)) {
break;
}
}
ret = d - buffer;
if (ret > 0) {
*d = '\0';
}
if (read_flag == TRUE) {
fs_file_seek(file, offset);
}
return ret;
}
ret_t fs_build_user_storage_file_name(char filename[MAX_PATH + 1], const char* appname,
const char* name) {
char home[MAX_PATH + 1];
char path[MAX_PATH + 1];
return_value_if_fail(filename != NULL && appname != NULL && name != NULL, RET_FAIL);
return_value_if_fail(fs_get_user_storage_path(os_fs(), home) == RET_OK, RET_FAIL);
return_value_if_fail(path_build(path, MAX_PATH, home, appname, NULL) == RET_OK, RET_FAIL);
if (!path_exist(path)) {
fs_create_dir(os_fs(), path);
}
return path_build(filename, MAX_PATH, path, name, NULL);
}
#include "tkc/tokenizer.h"
ret_t fs_create_dir_r(fs_t* fs, const char* name) {
int32_t len = 0;
char path[MAX_PATH + 1];
ret_t ret = RET_OK;
tokenizer_t tokenizer;
tokenizer_t* t = NULL;
return_value_if_fail(fs != NULL && name != NULL, RET_BAD_PARAMS);
t = tokenizer_init(&tokenizer, name, strlen(name), "/\\");
return_value_if_fail(t != NULL, RET_BAD_PARAMS);
while (tokenizer_has_more(t)) {
tokenizer_next(t);
len = tk_min(MAX_PATH, t->cursor);
tk_strncpy(path, name, len);
if (len > 0) {
if (path[len - 1] == '/' || path[len - 1] == '\\') {
path[len - 1] = '\0';
}
}
if (!fs_dir_exist(fs, path)) {
if (fs_create_dir(fs, path) != RET_OK) {
log_debug("create %s failed\n", path);
ret = RET_FAIL;
break;
}
}
}
tokenizer_deinit(t);
return ret;
}
ret_t fs_remove_dir_r(fs_t* fs, const char* name) {
fs_item_t item;
ret_t ret = RET_OK;
fs_dir_t* dir = NULL;
return_value_if_fail(fs != NULL && name != NULL, RET_BAD_PARAMS);
dir = fs_open_dir(fs, name);
return_value_if_fail(dir != NULL, RET_BAD_PARAMS);
do {
if (fs_dir_read(dir, &item) != RET_OK) {
break;
}
if (tk_str_eq(item.name, ".") || tk_str_eq(item.name, "..")) {
continue;
} else {
char subname[MAX_PATH + 1];
path_build(subname, MAX_PATH, name, item.name, NULL);
if (item.is_dir) {
ret = fs_remove_dir_r(fs, subname);
} else {
ret = fs_remove_file(fs, subname);
}
}
if (ret != RET_OK) {
break;
}
} while (TRUE);
fs_dir_close(dir);
ret = fs_remove_dir(fs, name);
return ret;
}
bool_t fs_dir_is_empty(fs_t* fs, const char* name) {
bool_t ret = TRUE;
fs_dir_t* dir = NULL;
fs_item_t item;
return_value_if_fail(fs != NULL && name != NULL, ret);
dir = fs_open_dir(fs, name);
return_value_if_fail(dir != NULL, ret);
do {
if (fs_dir_read(dir, &item) != RET_OK) {
break;
}
if (tk_str_eq(item.name, ".") || tk_str_eq(item.name, "..")) {
continue;
} else {
ret = FALSE;
}
} while (ret);
fs_dir_close(dir);
return ret;
}
#ifndef TK_COPY_BUFF_SIZE
#define TK_COPY_BUFF_SIZE 4096
#endif /*TK_COPY_BUFF_SIZE*/
static ret_t fs_copy_file_fd(fs_file_t* fsrc, fs_file_t* fdst) {
int32_t r = 0;
ret_t ret = RET_OK;
uint8_t* buff = TKMEM_ALLOC(TK_COPY_BUFF_SIZE + 1);
return_value_if_fail(buff != NULL, RET_OOM);
while ((r = fs_file_read(fsrc, buff, TK_COPY_BUFF_SIZE)) > 0) {
buff[r] = '\0';
if (fs_file_write(fdst, buff, r) < r) {
log_debug("write file failed\n");
ret = RET_IO;
break;
}
}
TKMEM_FREE(buff);
return ret;
}
ret_t fs_copy_file(fs_t* fs, const char* src, const char* dst) {
ret_t ret = RET_FAIL;
fs_file_t* fsrc = NULL;
fs_file_t* fdst = NULL;
char dirname[MAX_PATH + 1];
return_value_if_fail(fs != NULL && src != NULL && dst != NULL, RET_BAD_PARAMS);
return_value_if_fail(file_exist(src), RET_BAD_PARAMS);
path_dirname(dst, dirname, MAX_PATH);
if (!dir_exist(dirname)) {
return_value_if_fail(fs_create_dir_r(fs, dirname) == RET_OK, RET_IO);
}
fdst = fs_open_file(fs, dst, "wb+");
return_value_if_fail(fdst != NULL, RET_IO);
fsrc = fs_open_file(fs, src, "rb");
if (fsrc != NULL) {
ret = fs_copy_file_fd(fsrc, fdst);
fs_file_close(fsrc);
}
fs_file_close(fdst);
return ret;
}
bool_t fs_file_equal(fs_t* fs, const char* src, const char* dst) {
int32_t slen = 0;
int32_t dlen = 0;
bool_t ret = FALSE;
fs_file_t* fsrc = NULL;
fs_file_t* fdst = NULL;
uint8_t sbuff[1024] = {0};
uint8_t dbuff[1024] = {0};
return_value_if_fail(fs != NULL && src != NULL && dst != NULL, FALSE);
return_value_if_fail(file_exist(src), FALSE);
return_value_if_fail(file_exist(dst), FALSE);
fdst = fs_open_file(fs, dst, "rb");
return_value_if_fail(fdst != NULL, FALSE);
fsrc = fs_open_file(fs, src, "rb");
if (fsrc != NULL) {
if (fs_file_size(fsrc) != fs_file_size(fdst)) {
goto end;
}
while (TRUE) {
slen = fs_file_read(fsrc, sbuff, sizeof(sbuff));
dlen = fs_file_read(fdst, dbuff, sizeof(dbuff));
if (slen != dlen) {
goto end;
}
if (memcmp(sbuff, dbuff, slen) != 0) {
goto end;
}
if (fs_file_eof(fsrc)) {
ret = TRUE;
break;
}
}
}
end:
if (fsrc != NULL) {
fs_file_close(fsrc);
}
if (fdst != NULL) {
fs_file_close(fdst);
}
return ret;
}
static ret_t fs_copy_item(fs_t* fs, fs_item_t* item, const char* src, const char* dst,
bool_t overwrite) {
char subsrc[MAX_PATH + 1];
char subdst[MAX_PATH + 1];
path_build(subsrc, MAX_PATH, src, item->name, NULL);
path_build(subdst, MAX_PATH, dst, item->name, NULL);
if (!fs_dir_exist(fs, dst)) {
return_value_if_fail(fs_create_dir_r(fs, dst) == RET_OK, RET_IO);
}
if (item->is_dir) {
log_debug("%s ==> %s\n", subsrc, subdst);
return fs_copy_dir_ex(fs, subsrc, subdst, overwrite);
} else {
if (file_exist(subdst) && !overwrite) {
log_debug("%s ==> %s(skipped)\n", subsrc, subdst);
return RET_OK;
}
log_debug("%s ==> %s\n", subsrc, subdst);
return fs_copy_file(fs, subsrc, subdst);
}
}
ret_t fs_copy_dir(fs_t* fs, const char* src, const char* dst) {
return fs_copy_dir_ex(fs, src, dst, TRUE);
}
ret_t fs_copy_dir_ex(fs_t* fs, const char* src, const char* dst, bool_t overwrite) {
fs_item_t item;
ret_t ret = RET_OK;
fs_dir_t* dir = NULL;
return_value_if_fail(fs != NULL && src != NULL && dst != NULL, RET_BAD_PARAMS);
return_value_if_fail(fs_dir_exist(fs, src), RET_BAD_PARAMS);
if (!fs_dir_exist(fs, dst)) {
return_value_if_fail(fs_create_dir_r(fs, dst) == RET_OK, RET_IO);
}
dir = fs_open_dir(fs, src);
return_value_if_fail(dir != NULL, RET_BAD_PARAMS);
do {
if (fs_dir_read(dir, &item) != RET_OK) {
break;
}
if (tk_str_eq(item.name, ".") || tk_str_eq(item.name, "..")) {
continue;
} else {
ret = fs_copy_item(fs, &item, src, dst, overwrite);
}
if (ret != RET_OK) {
break;
}
} while (TRUE);
fs_dir_close(dir);
return ret;
}
ret_t fs_foreach_file(const char* path, tk_visit_t on_file, void* ctx) {
fs_item_t item;
fs_t* fs = os_fs();
fs_dir_t* dir = NULL;
char filename[MAX_PATH + 1];
return_value_if_fail(fs != NULL && path != NULL && on_file != NULL, RET_BAD_PARAMS);
dir = fs_open_dir(fs, path);
return_value_if_fail(dir != NULL, RET_BAD_PARAMS);
while (fs_dir_read(dir, &item) == RET_OK) {
if (tk_str_eq(item.name, ".") || tk_str_eq(item.name, "..")) {
continue;
}
path_build(filename, MAX_PATH, path, item.name, NULL);
if (item.is_reg_file) {
if (on_file(ctx, filename) != RET_OK) {
break;
}
} else if (item.is_dir) {
fs_foreach_file(filename, on_file, ctx);
}
}
fs_dir_close(dir);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/color_parser.c
|
#include "color_parser.h"
#include "tkc/str.h"
#include "tkc/mem.h"
#include "tkc/utils.h"
typedef struct _color_map_t {
const char* name;
const char* value;
} color_map_t;
static color_map_t const colors_map[] = {{"aliceblue", "#f0f8ff"},
{"antiquewhite", "#faebd7"},
{"aqua", "#00ffff"},
{"aquamarine", "#7fffd4"},
{"azure", "#f0ffff"},
{"beige", "#f5f5dc"},
{"bisque", "#ffe4c4"},
{"black", "#000000"},
{"blanchedalmond", "#ffebcd"},
{"blue", "#0000ff"},
{"blueviolet", "#8a2be2"},
{"brown", "#a52a2a"},
{"burlywood", "#deb887"},
{"cadetblue", "#5f9ea0"},
{"chartreuse", "#7fff00"},
{"chocolate", "#d2691e"},
{"coral", "#ff7f50"},
{"cornflowerblue", "#6495ed"},
{"cornsilk", "#fff8dc"},
{"crimson", "#dc143c"},
{"cyan", "#00ffff"},
{"darkblue", "#00008b"},
{"darkcyan", "#008b8b"},
{"darkgoldenrod", "#b8860b"},
{"darkgray", "#a9a9a9"},
{"darkgreen", "#006400"},
{"darkkhaki", "#bdb76b"},
{"darkmagenta", "#8b008b"},
{"darkolivegreen", "#556b2f"},
{"darkorange", "#ff8c00"},
{"darkorchid", "#9932cc"},
{"darkred", "#8b0000"},
{"darksalmon", "#e9967a"},
{"darkseagreen", "#8fbc8f"},
{"darkslateblue", "#483d8b"},
{"darkslategray", "#2f4f4f"},
{"darkturquoise", "#00ced1"},
{"darkviolet", "#9400d3"},
{"deeppink", "#ff1493"},
{"deepskyblue", "#00bfff"},
{"dimgray", "#696969"},
{"dodgerblue", "#1e90ff"},
{"firebrick", "#b22222"},
{"floralwhite", "#fffaf0"},
{"forestgreen", "#228b22"},
{"fuchsia", "#ff00ff"},
{"gainsboro", "#dcdcdc"},
{"ghostwhite", "#f8f8ff"},
{"gold", "#ffd700"},
{"goldenrod", "#daa520"},
{"gray", "#bebebe"},
{"green", "#008000"},
{"greenyellow", "#adff2f"},
{"honeydew", "#f0fff0"},
{"hotpink", "#ff69b4"},
{"indianred", "#cd5c5c"},
{"indigo", "#4b0082"},
{"ivory", "#fffff0"},
{"khaki", "#f0d58c"},
{"lavender", "#e6e6fa"},
{"lavenderblush", "#fff0f5"},
{"lawngreen", "#7cfc00"},
{"lemonchiffon", "#fffacd"},
{"lightblue", "#add8e6"},
{"lightcoral", "#f08080"},
{"lightcyan", "#e0ffff"},
{"lightgoldenrodyellow", "#fafad2"},
{"lightgreen", "#90ee90"},
{"lightgrey", "#d3d3d3"},
{"lightpink", "#ffb6c1"},
{"lightsalmon", "#ffa07a"},
{"lightseagreen", "#20b2aa"},
{"lightskyblue", "#87cefa"},
{"lightslategray", "#778899"},
{"lightsteelblue", "#b0c4de"},
{"lightyellow", "#ffffe0"},
{"lime", "#00ff00"},
{"limegreen", "#32cd32"},
{"linen", "#faf0e6"},
{"magenta", "#ff00ff"},
{"maroon", "#800000"},
{"mediumaquamarine", "#66cdaa"},
{"mediumblue", "#0000cd"},
{"mediumorchid", "#ba55d3"},
{"mediumpurple", "#9370db"},
{"mediumseagreen", "#3cb371"},
{"mediumslateblue", "#7b68ee"},
{"mediumspringgreen", "#00fa9a"},
{"mediumturquoise", "#48d1cc"},
{"mediumvioletred", "#c71585"},
{"midnightblue", "#191970"},
{"mintcream", "#f5fffa"},
{"mistyrose", "#ffe4e1"},
{"moccasin", "#ffe4b5"},
{"navajowhite", "#ffdead"},
{"navy", "#000080"},
{"oldlace", "#fdf5e6"},
{"olive", "#808000"},
{"olivedrab", "#6b8e23"},
{"orange", "#ffa500"},
{"orangered", "#ff4500"},
{"orchid", "#da70d6"},
{"palegoldenrod", "#eee8aa"},
{"palegreen", "#98fb98"},
{"paleturquoise", "#afeeee"},
{"palevioletred", "#db7093"},
{"papayawhip", "#ffefd5"},
{"peachpuff", "#ffdab9"},
{"peru", "#cd853f"},
{"pink", "#ffc0cb"},
{"plum", "#dda0dd"},
{"powderblue", "#b0e0e6"},
{"purple", "#800080"},
{"red", "#ff0000"},
{"rosybrown", "#bc8f8f"},
{"royalblue", "#4169e1"},
{"saddlebrown", "#8b4513"},
{"salmon", "#fa8072"},
{"sandybrown", "#f4a460"},
{"seagreen", "#2e8b57"},
{"seashell", "#fff5ee"},
{"sienna", "#a0522d"},
{"silver", "#c0c0c0"},
{"skyblue", "#87ceeb"},
{"slateblue", "#6a5acd"},
{"slategray", "#708090"},
{"snow", "#fffafa"},
{"springgreen", "#00ff7f"},
{"steelblue", "#4682b4"},
{"tan", "#d2b48c"},
{"teal", "#008080"},
{"thistle", "#d8bfd8"},
{"tomato", "#ff6347"},
{"turquoise", "#40e0d0"},
{"violet", "#ee82ee"},
{"wheat", "#f5deb3"},
{"white", "#ffffff"},
{"whitesmoke", "#f5f5f5"},
{"yellow", "#ffff00"},
{"yellowgreen", "#9acd32"}};
static int compare_color(const color_map_t* a, const color_map_t* b) {
return strcasecmp(a->name, b->name);
}
static const char* map_name_to_value(const char* name) {
color_map_t color_map;
color_map.name = name;
color_map.value = NULL;
color_map_t* ret = (color_map_t*)bsearch(&color_map, colors_map, ARRAY_SIZE(colors_map),
sizeof(color_map_t), (tk_compare_t)compare_color);
return ret ? ret->value : NULL;
}
static bool_t color_parse_rgba(const char* color, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) {
uint32_t len = strlen(color);
return_value_if_fail(len > 6, FALSE);
int ir = 0;
int ig = 0;
int ib = 0;
float fa = 1;
if (strstr(color, "rgba") != NULL) {
tk_sscanf(color, "rgba(%d,%d,%d,%f)", &ir, &ig, &ib, &fa);
} else {
tk_sscanf(color, "rgb(%d,%d,%d)", &ir, &ig, &ib);
}
*r = ir & 0xff;
*g = ig & 0xff;
*b = ib & 0xff;
*a = (int)(fa * 255) & 0xff;
return TRUE;
}
static bool_t color_parse_hex(const char* color, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) {
uint32_t len = strlen(color);
return_value_if_fail(len > 6, FALSE);
int ir = 0;
int ig = 0;
int ib = 0;
int ia = 0xff;
if (len < 8) {
tk_sscanf(color, "#%02x%02x%02x", &ir, &ig, &ib);
} else {
tk_sscanf(color, "#%02x%02x%02x%02x", &ir, &ig, &ib, &ia);
}
*r = ir & 0xff;
*g = ig & 0xff;
*b = ib & 0xff;
*a = ia & 0xff;
return TRUE;
}
static bool_t color_parse_impl(const char* color, uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) {
str_t s;
str_t* str;
bool_t ret = FALSE;
return_value_if_fail(color != NULL && r != NULL && g != NULL && b != NULL && a != NULL, FALSE);
*r = 0;
*b = 0;
*g = 0;
*a = 0;
str = str_init(&s, 10);
str_set(str, color);
if (str_start_with(str, "rgb")) {
str_to_lower(str);
str_replace(str, " ", "");
ret = color_parse_rgba(str->str, r, g, b, a);
} else {
const char* value = color[0] == '#' ? color : map_name_to_value(color);
if (value) {
str_set(str, value);
str_to_lower(str);
ret = color_parse_hex(str->str, r, g, b, a);
}
}
str_reset(str);
return ret;
}
color_t color_parse(const char* color) {
uint8_t r = 0;
uint8_t g = 0;
uint8_t b = 0;
uint8_t a = 0xff;
color_parse_impl(color, &r, &g, &b, &a);
return color_init(r, g, b, a);
}
color_t* color_from_str(color_t* c, const char* str) {
return_value_if_fail(c != NULL && str != NULL, NULL);
*c = color_parse(str);
return c;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/time_now.h
|
/**
* File: time.h
* Author: AWTK Develop Team
* Brief: time
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-28 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TIME_NOW_H
#define TK_TIME_NOW_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class time_now_t
* @annotation ["scriptable", "fake"]
* 获取当前时间的函数。
* 这里的当前时间是相对的，在嵌入式系统一般相对于开机时间(毫秒)。
* 它本身并没有任何意义，一般用来计算时间间隔，如实现定时器和动画等等。
*/
/**
* @method time_now_s
* 获取当前时间(秒)。
*
* 备注: 时间本身并不代表任何时间系，一般用来计算时间间隔。
* @annotation ["scriptable", "static"]
*
* @return {uint64_t} 返回当前时间(秒)。
*/
uint64_t time_now_s(void);
/**
* @method time_now_ms
* 获取当前时间(毫秒)。
*
* 备注: 时间本身并不代表任何时间系，一般用来计算时间间隔。
* @annotation ["scriptable", "static"]
*
* @return {uint64_t} 返回当前时间(毫秒)。
*/
uint64_t time_now_ms(void);
/**
* @method time_now_us
* 获取当前时间(微秒)。
*
* 备注: 时间本身并不代表任何时间系，一般用来计算时间间隔。
* @annotation ["scriptable", "static"]
*
* @return {uint64_t} 返回当前时间(微秒)。
*/
uint64_t time_now_us(void);
END_C_DECLS
#endif /*TK_TIME_NOW_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/socket_pair.h
|
/**
* File: socket_pair.h
* Author: AWTK Develop Team
* Brief: socket pair
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SOCKET_PAIR_H
#define TK_SOCKET_PAIR_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class socketpair_t
* @annotation ["fake"]
* socketpair
*/
/**
* @method tk_socketpair
* 生成两个socket句柄。两者可以模拟客户端和服务器通信。
*
* @param {int*} socks 由于返回生成的socket句柄。
*
* @return {int} 小于0表示失败。
*/
int tk_socketpair(int socks[2]);
END_C_DECLS
#endif /*TK_SOCKET_PAIR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/serial_helper.c
|
/**
* File: serial_helper.c
* Author: AWTK Develop Team
* Brief: serial helper functions
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-11 Li XianJing <[email protected]> created
*
*/
/*
*the following code adapted from: https://github.com/wjwwood/serial/tree/master/src/impl
*
* Copyright 2012 William Woodall and John Harrison
*
* Additional Contributors: Christopher Baker @bakercp
*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif /*WIN32_LEAN_AND_MEAN*/
#include "tkc/mem.h"
#include "tkc/wstr.h"
#include "tkc/thread.h"
#include "tkc/time_now.h"
#include "tkc/serial_helper.h"
#if defined(TK_IS_PC) || defined(LINUX) || defined(IOS) || defined(ANDROID)
#include "tkc/socket_pair.h"
#include "tkc/socket_helper.h"
#endif /*TK_IS_PC*/
#ifdef WIN32
#define prefix L"\\\\.\\"
static ret_t serial_wait_for_data_impl(serial_handle_t handle, uint32_t timeout_ms);
int serial_handle_get_fd(serial_handle_t handle) {
return handle->client_fd;
}
serial_dev_t serial_handle_get_dev(serial_handle_t handle) {
return handle->dev;
}
static ret_t serial_cond_var_wait(serial_handle_t handle, uint32_t timeout_ms) {
ret_t ret = RET_OK;
tk_mutex_lock(handle->mutex);
if (!handle->has_signal) {
ret = tk_cond_wait_timeout(handle->cond, handle->mutex, timeout_ms);
}
handle->has_signal = FALSE;
tk_mutex_unlock(handle->mutex);
return ret;
}
static ret_t serial_cond_var_awake(serial_handle_t handle) {
return_value_if_fail(handle->cond != NULL && handle->mutex, RET_BAD_PARAMS);
tk_mutex_lock(handle->mutex);
handle->has_signal = TRUE;
tk_mutex_unlock(handle->mutex);
tk_cond_signal(handle->cond);
return RET_OK;
}
static void* serial_thread_entry(void* args) {
char buff[1] = {0};
serial_handle_t handle = (serial_handle_t)args;
int fd = handle->server_fd;
while (!handle->closed) {
if (serial_wait_for_data_impl(handle, 100) == RET_OK) {
while (send(fd, buff, sizeof(buff), 0) <= 0) {
log_warn("send fb buff fail \r\n");
if (handle->closed) {
break;
}
}
serial_cond_var_wait(handle, 0xFFFFFFFF);
}
}
return NULL;
}
serial_handle_t serial_open(const char* port) {
wstr_t str;
serial_dev_t dev = 0;
int socks[2] = {0, 0};
serial_handle_t handle = NULL;
return_value_if_fail(port != NULL && *port != '\0', NULL);
wstr_init(&str, 256);
wstr_set_utf8(&str, port);
if (strstr(port, "\\\\.\\") != port) {
wstr_insert(&str, 0, prefix, wcslen(prefix));
}
dev = CreateFileW(str.str, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0);
wstr_reset(&str);
return_value_if_fail(dev != INVALID_HANDLE_VALUE, NULL);
handle = TKMEM_ZALLOC(serial_info_t);
return_value_if_fail(handle != NULL, NULL);
handle->dev = dev;
ZeroMemory(&handle->read_overlapped, sizeof(OVERLAPPED));
ZeroMemory(&handle->write_overlapped, sizeof(OVERLAPPED));
handle->read_overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
handle->write_overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
handle->cond = tk_cond_create();
handle->mutex = tk_mutex_create();
handle->thread = tk_thread_create(serial_thread_entry, handle);
if (!SetCommMask(dev, EV_RXCHAR) || handle->cond == NULL || handle->mutex == NULL ||
handle->thread == NULL || tk_socketpair(socks) < 0) {
serial_close(handle);
return NULL;
}
handle->client_fd = socks[0];
handle->server_fd = socks[1];
tk_thread_start(handle->thread);
return handle;
}
ret_t serial_config(serial_handle_t handle, uint32_t baudrate, bytesize_t bytesize,
stopbits_t stopbits, flowcontrol_t flowcontrol, parity_t parity) {
DCB dcbSerialParams = {0};
serial_dev_t dev = serial_handle_get_dev(handle);
return_value_if_fail(handle != NULL, RET_BAD_PARAMS);
dcbSerialParams.DCBlength = sizeof(dcbSerialParams);
if (!GetCommState(dev, &dcbSerialParams)) {
// error getting state
log_debug("Error getting the serial port state.");
return RET_FAIL;
}
// setup baud rate
switch (baudrate) {
#ifdef CBR_0
case 0:
dcbSerialParams.BaudRate = CBR_0;
break;
#endif
#ifdef CBR_50
case 50:
dcbSerialParams.BaudRate = CBR_50;
break;
#endif
#ifdef CBR_75
case 75:
dcbSerialParams.BaudRate = CBR_75;
break;
#endif
#ifdef CBR_110
case 110:
dcbSerialParams.BaudRate = CBR_110;
break;
#endif
#ifdef CBR_134
case 134:
dcbSerialParams.BaudRate = CBR_134;
break;
#endif
#ifdef CBR_150
case 150:
dcbSerialParams.BaudRate = CBR_150;
break;
#endif
#ifdef CBR_200
case 200:
dcbSerialParams.BaudRate = CBR_200;
break;
#endif
#ifdef CBR_300
case 300:
dcbSerialParams.BaudRate = CBR_300;
break;
#endif
#ifdef CBR_600
case 600:
dcbSerialParams.BaudRate = CBR_600;
break;
#endif
#ifdef CBR_1200
case 1200:
dcbSerialParams.BaudRate = CBR_1200;
break;
#endif
#ifdef CBR_1800
case 1800:
dcbSerialParams.BaudRate = CBR_1800;
break;
#endif
#ifdef CBR_2400
case 2400:
dcbSerialParams.BaudRate = CBR_2400;
break;
#endif
#ifdef CBR_4800
case 4800:
dcbSerialParams.BaudRate = CBR_4800;
break;
#endif
#ifdef CBR_7200
case 7200:
dcbSerialParams.BaudRate = CBR_7200;
break;
#endif
#ifdef CBR_9600
case 9600:
dcbSerialParams.BaudRate = CBR_9600;
break;
#endif
#ifdef CBR_14400
case 14400:
dcbSerialParams.BaudRate = CBR_14400;
break;
#endif
#ifdef CBR_19200
case 19200:
dcbSerialParams.BaudRate = CBR_19200;
break;
#endif
#ifdef CBR_28800
case 28800:
dcbSerialParams.BaudRate = CBR_28800;
break;
#endif
#ifdef CBR_57600
case 57600:
dcbSerialParams.BaudRate = CBR_57600;
break;
#endif
#ifdef CBR_76800
case 76800:
dcbSerialParams.BaudRate = CBR_76800;
break;
#endif
#ifdef CBR_38400
case 38400:
dcbSerialParams.BaudRate = CBR_38400;
break;
#endif
#ifdef CBR_115200
case 115200:
dcbSerialParams.BaudRate = CBR_115200;
break;
#endif
#ifdef CBR_128000
case 128000:
dcbSerialParams.BaudRate = CBR_128000;
break;
#endif
#ifdef CBR_153600
case 153600:
dcbSerialParams.BaudRate = CBR_153600;
break;
#endif
#ifdef CBR_230400
case 230400:
dcbSerialParams.BaudRate = CBR_230400;
break;
#endif
#ifdef CBR_256000
case 256000:
dcbSerialParams.BaudRate = CBR_256000;
break;
#endif
#ifdef CBR_460800
case 460800:
dcbSerialParams.BaudRate = CBR_460800;
break;
#endif
#ifdef CBR_921600
case 921600:
dcbSerialParams.BaudRate = CBR_921600;
break;
#endif
default:
// Try to blindly assign it
dcbSerialParams.BaudRate = baudrate;
}
// setup char len
if (bytesize == eightbits)
dcbSerialParams.ByteSize = 8;
else if (bytesize == sevenbits)
dcbSerialParams.ByteSize = 7;
else if (bytesize == sixbits)
dcbSerialParams.ByteSize = 6;
else if (bytesize == fivebits)
dcbSerialParams.ByteSize = 5;
else
log_debug("invalid char len");
// setup stopbits
if (stopbits == stopbits_one)
dcbSerialParams.StopBits = ONESTOPBIT;
else if (stopbits == stopbits_one_point_five)
dcbSerialParams.StopBits = ONE5STOPBITS;
else if (stopbits == stopbits_two)
dcbSerialParams.StopBits = TWOSTOPBITS;
else
log_debug("invalid stop bit");
// setup parity
if (parity == parity_none) {
dcbSerialParams.Parity = NOPARITY;
} else if (parity == parity_even) {
dcbSerialParams.Parity = EVENPARITY;
} else if (parity == parity_odd) {
dcbSerialParams.Parity = ODDPARITY;
} else if (parity == parity_mark) {
dcbSerialParams.Parity = MARKPARITY;
} else if (parity == parity_space) {
dcbSerialParams.Parity = SPACEPARITY;
} else {
log_debug("invalid parity");
}
// setup flowcontrol
if (flowcontrol == flowcontrol_none) {
dcbSerialParams.fOutxCtsFlow = FALSE;
dcbSerialParams.fRtsControl = RTS_CONTROL_DISABLE;
dcbSerialParams.fOutX = FALSE;
dcbSerialParams.fInX = FALSE;
}
if (flowcontrol == flowcontrol_software) {
dcbSerialParams.fOutxCtsFlow = FALSE;
dcbSerialParams.fRtsControl = RTS_CONTROL_DISABLE;
dcbSerialParams.fOutX = TRUE;
dcbSerialParams.fInX = TRUE;
}
if (flowcontrol == flowcontrol_hardware) {
dcbSerialParams.fOutxCtsFlow = TRUE;
dcbSerialParams.fRtsControl = RTS_CONTROL_HANDSHAKE;
dcbSerialParams.fOutX = FALSE;
dcbSerialParams.fInX = FALSE;
}
// activate settings
if (!SetCommState(dev, &dcbSerialParams)) {
log_debug("Error setting serial port settings.");
return RET_FAIL;
}
// Setup timeouts
COMMTIMEOUTS timeouts = {0};
timeouts.ReadIntervalTimeout = 10;
timeouts.ReadTotalTimeoutConstant = 100;
timeouts.ReadTotalTimeoutMultiplier = 0;
timeouts.WriteTotalTimeoutConstant = 100;
timeouts.WriteTotalTimeoutMultiplier = 10;
if (!SetCommTimeouts(dev, &timeouts)) {
log_debug("Error setting timeouts.");
return RET_FAIL;
}
return RET_OK;
}
ret_t serial_iflush(serial_handle_t handle) {
serial_dev_t dev = serial_handle_get_dev(handle);
PurgeComm(dev, PURGE_RXCLEAR);
return RET_OK;
}
ret_t serial_oflush(serial_handle_t handle) {
serial_dev_t dev = serial_handle_get_dev(handle);
PurgeComm(dev, PURGE_TXCLEAR);
return RET_OK;
}
ret_t serial_close(serial_handle_t handle) {
if (handle != NULL) {
serial_dev_t dev = serial_handle_get_dev(handle);
serial_iflush(handle);
serial_oflush(handle);
if (dev != INVALID_HANDLE_VALUE) {
CancelIo(dev);
CloseHandle(dev);
}
if (handle->read_overlapped.hEvent != INVALID_HANDLE_VALUE) {
CloseHandle(handle->read_overlapped.hEvent);
}
if (handle->write_overlapped.hEvent != INVALID_HANDLE_VALUE) {
CloseHandle(handle->write_overlapped.hEvent);
}
handle->closed = TRUE;
serial_cond_var_awake(handle);
if (handle->thread != NULL) {
tk_thread_join(handle->thread);
tk_thread_destroy(handle->thread);
}
tk_socket_close(handle->client_fd);
tk_socket_close(handle->server_fd);
if (handle->mutex != NULL) {
tk_mutex_destroy(handle->mutex);
}
if (handle->cond != NULL) {
tk_cond_destroy(handle->cond);
}
memset(handle, 0x0, sizeof(*handle));
TKMEM_FREE(handle);
}
return RET_OK;
}
int32_t serial_read(serial_handle_t handle, uint8_t* buff, uint32_t max_size) {
DWORD err = 0;
DWORD bytes = 0;
char tmp_buff[1] = {0};
bool_t has_signal = FALSE;
serial_dev_t dev = serial_handle_get_dev(handle);
if (serial_wait_for_data(handle, 0) != RET_OK) {
return 0;
}
if (!ReadFile(dev, buff, max_size, &bytes, &handle->read_overlapped)) {
err = GetLastError();
if (err == ERROR_IO_PENDING) {
GetOverlappedResult(dev, &handle->read_overlapped, &bytes, TRUE);
} else {
bytes = 0;
}
}
tk_mutex_lock(handle->mutex);
if (!handle->has_signal) {
if (recv(handle->client_fd, tmp_buff, sizeof(tmp_buff), 0) > 0) {
handle->has_signal = has_signal = TRUE;
}
}
tk_mutex_unlock(handle->mutex);
if (has_signal) {
tk_cond_signal(handle->cond);
}
return bytes;
}
int32_t serial_write(serial_handle_t handle, const uint8_t* buff, uint32_t max_size) {
DWORD err = 0;
DWORD real_send = 0;
serial_dev_t dev = serial_handle_get_dev(handle);
if (!WriteFile(dev, buff, max_size, &real_send, &handle->write_overlapped)) {
err = GetLastError();
if (err == ERROR_IO_PENDING) {
GetOverlappedResult(dev, &handle->write_overlapped, &real_send, TRUE);
} else {
real_send = 0;
}
}
ClearCommError(dev, &err, NULL);
return real_send;
}
static ret_t serial_wait_for_data_impl(serial_handle_t handle, uint32_t timeout_ms) {
DWORD err = 0;
DWORD mask = 0;
COMSTAT cstate = {0};
ret_t ret = RET_FAIL;
serial_dev_t dev = serial_handle_get_dev(handle);
if (!WaitCommEvent(dev, &mask, &handle->read_overlapped)) {
err = GetLastError();
if (err == ERROR_IO_PENDING) {
err = WaitForSingleObject(handle->read_overlapped.hEvent, timeout_ms);
if (err == WAIT_OBJECT_0) {
ret = RET_OK;
} else if (err == WAIT_TIMEOUT) {
ret = RET_TIMEOUT;
} else {
ret = RET_FAIL;
}
}
}
/* 清除可能的异常以及其事件，同时获取缓冲区的数据个数 */
ClearCommError(dev, &err, &cstate);
if (cstate.cbInQue > 0) {
/* 如果缓冲区有数据的话，应该触发 serial_wait_for_data 让其他取缓冲区的数据。*/
ret = RET_OK;
} else if (ret == RET_OK) {
sleep_ms(timeout_ms);
/* 如果缓冲区没有数据的话，但是却触发了 WaitForSingleObject 触发成功了，说明串口通信有异常，则应该返回 RET_FAIL。*/
ret = RET_FAIL;
}
return ret;
}
ret_t serial_wait_for_data(serial_handle_t handle, uint32_t timeout_ms) {
int fd = serial_handle_get_fd(handle);
return tk_socket_wait_for_data(fd, timeout_ms);
}
#elif defined(LINUX) || defined(MACOS) || defined(IOS) || defined(ANDROID)
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <errno.h>
#include <paths.h>
#include <sysexits.h>
#include <termios.h>
#include <sys/param.h>
#include <pthread.h>
#if defined(__linux__)
#include <linux/serial.h>
#endif
#include <sys/select.h>
#include <sys/time.h>
#include <time.h>
#ifdef __MACH__
#include <AvailabilityMacros.h>
#endif
#ifndef TIOCINQ
#ifdef FIONREAD
#define TIOCINQ FIONREAD
#else
#define TIOCINQ 0x541B
#endif
#endif
#if defined(MAC_OS_X_VERSION_10_3) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3)
#if defined(IOS)
#include <sys/termios.h>
#include <sys/ttycom.h>
#define IOSSIOSPEED _IOW('T', 2, speed_t)
#else
#include <IOKit/serial/ioss.h>
#endif /*IOS*/
#endif
serial_handle_t serial_open(const char* port) {
int flags = 0;
serial_handle_t handle = TKMEM_ZALLOC(serial_info_t);
return_value_if_fail(handle != NULL && port != NULL && *port != '\0', NULL);
flags = O_RDWR | O_NOCTTY | O_NDELAY | O_EXCL;
#ifdef O_CLOEXEC
flags |= O_CLOEXEC;
#endif
handle->dev = open(port, flags);
if (handle->dev <= 0) {
TKMEM_FREE(handle);
return NULL;
}
handle->old_options = TKMEM_ALLOC(sizeof(struct termios));
return handle;
}
ret_t serial_config(serial_handle_t handle, uint32_t baudrate, bytesize_t bytesize,
stopbits_t stopbits, flowcontrol_t flowcontrol, parity_t parity) {
bool_t xonxoff = FALSE;
bool_t rtscts = FALSE;
int32_t byte_time_ns = 0;
struct termios options;
serial_dev_t dev = serial_handle_get_dev(handle);
return_value_if_fail(dev >= 0, RET_BAD_PARAMS);
(void)byte_time_ns;
return_value_if_fail(tcgetattr(dev, (struct termios*)handle->old_options) >= 0, RET_BAD_PARAMS);
memset(&options, 0x0, sizeof(struct termios));
options.c_cflag |= (tcflag_t)(CLOCAL | CREAD);
options.c_lflag &=
(tcflag_t) ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL | ISIG | IEXTEN); //|ECHOPRT
options.c_oflag &= (tcflag_t) ~(OPOST);
options.c_iflag &= (tcflag_t) ~(INLCR | IGNCR | ICRNL | IGNBRK);
#ifdef IUCLC
options.c_iflag &= (tcflag_t)~IUCLC;
#endif
#ifdef PARMRK
options.c_iflag &= (tcflag_t)~PARMRK;
#endif
// setup baud rate
bool_t custom_baud = FALSE;
speed_t baud;
switch (baudrate) {
#ifdef B0
case 0:
baud = B0;
break;
#endif
#ifdef B50
case 50:
baud = B50;
break;
#endif
#ifdef B75
case 75:
baud = B75;
break;
#endif
#ifdef B110
case 110:
baud = B110;
break;
#endif
#ifdef B134
case 134:
baud = B134;
break;
#endif
#ifdef B150
case 150:
baud = B150;
break;
#endif
#ifdef B200
case 200:
baud = B200;
break;
#endif
#ifdef B300
case 300:
baud = B300;
break;
#endif
#ifdef B600
case 600:
baud = B600;
break;
#endif
#ifdef B1200
case 1200:
baud = B1200;
break;
#endif
#ifdef B1800
case 1800:
baud = B1800;
break;
#endif
#ifdef B2400
case 2400:
baud = B2400;
break;
#endif
#ifdef B4800
case 4800:
baud = B4800;
break;
#endif
#ifdef B7200
case 7200:
baud = B7200;
break;
#endif
#ifdef B9600
case 9600:
baud = B9600;
break;
#endif
#ifdef B14400
case 14400:
baud = B14400;
break;
#endif
#ifdef B19200
case 19200:
baud = B19200;
break;
#endif
#ifdef B28800
case 28800:
baud = B28800;
break;
#endif
#ifdef B57600
case 57600:
baud = B57600;
break;
#endif
#ifdef B76800
case 76800:
baud = B76800;
break;
#endif
#ifdef B38400
case 38400:
baud = B38400;
break;
#endif
#ifdef B115200
case 115200:
baud = B115200;
break;
#endif
#ifdef B128000
case 128000:
baud = B128000;
break;
#endif
#ifdef B153600
case 153600:
baud = B153600;
break;
#endif
#ifdef B230400
case 230400:
baud = B230400;
break;
#endif
#ifdef B256000
case 256000:
baud = B256000;
break;
#endif
#ifdef B460800
case 460800:
baud = B460800;
break;
#endif
#ifdef B500000
case 500000:
baud = B500000;
break;
#endif
#ifdef B576000
case 576000:
baud = B576000;
break;
#endif
#ifdef B921600
case 921600:
baud = B921600;
break;
#endif
#ifdef B1000000
case 1000000:
baud = B1000000;
break;
#endif
#ifdef B1152000
case 1152000:
baud = B1152000;
break;
#endif
#ifdef B1500000
case 1500000:
baud = B1500000;
break;
#endif
#ifdef B2000000
case 2000000:
baud = B2000000;
break;
#endif
#ifdef B2500000
case 2500000:
baud = B2500000;
break;
#endif
#ifdef B3000000
case 3000000:
baud = B3000000;
break;
#endif
#ifdef B3500000
case 3500000:
baud = B3500000;
break;
#endif
#ifdef B4000000
case 4000000:
baud = B4000000;
break;
#endif
default:
custom_baud = TRUE;
// OS X support
#if defined(MAC_OS_X_VERSION_10_4) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4)
// Starting with Tiger, the IOSSIOSPEED ioctl can be used to set arbitrary baud rates
// other than those specified by POSIX. The driver for the underlying serial hardware
// ultimately determines which baud rates can be used. This ioctl sets both the input
// and output speed.
speed_t new_baud = (speed_t)(baudrate);
return_value_if_fail(ioctl(dev, IOSSIOSPEED, &new_baud, 1) >= 0, RET_FAIL);
// Linux Support
#elif defined(__linux__) && defined(TIOCSSERIAL)
struct serial_struct ser;
return_value_if_fail(ioctl(dev, TIOCGSERIAL, &ser) >= 0, RET_FAIL);
// set custom divisor
ser.custom_divisor = ser.baud_base / (int)(baudrate);
// update flags
ser.flags &= ~ASYNC_SPD_MASK;
ser.flags |= ASYNC_SPD_CUST;
return_value_if_fail(ioctl(dev, TIOCSSERIAL, &ser) >= 0, RET_FAIL);
#else
log_debug("OS does not currently support custom bauds");
return RET_FAIL;
#endif
}
if (custom_baud == FALSE) {
#ifdef _BSD_SOURCE
cfsetspeed(&options, baud);
#else
cfsetispeed(&options, baud);
cfsetospeed(&options, baud);
#endif
}
// setup char len
options.c_cflag &= (tcflag_t)~CSIZE;
if (bytesize == eightbits)
options.c_cflag |= CS8;
else if (bytesize == sevenbits)
options.c_cflag |= CS7;
else if (bytesize == sixbits)
options.c_cflag |= CS6;
else if (bytesize == fivebits)
options.c_cflag |= CS5;
else
log_debug("invalid char len");
// setup stopbits
if (stopbits == stopbits_one)
options.c_cflag &= (tcflag_t) ~(CSTOPB);
else if (stopbits == stopbits_one_point_five)
// ONE POINT FIVE same as TWO.. there is no POSIX support for 1.5
options.c_cflag |= (CSTOPB);
else if (stopbits == stopbits_two)
options.c_cflag |= (CSTOPB);
else
log_debug("invalid stop bit");
// setup parity
options.c_iflag &= (tcflag_t) ~(INPCK | ISTRIP);
if (parity == parity_none) {
options.c_cflag &= (tcflag_t) ~(PARENB | PARODD);
} else if (parity == parity_even) {
options.c_cflag &= (tcflag_t) ~(PARODD);
options.c_cflag |= (PARENB);
} else if (parity == parity_odd) {
options.c_cflag |= (PARENB | PARODD);
}
#ifdef CMSPAR
else if (parity == parity_mark) {
options.c_cflag |= (PARENB | CMSPAR | PARODD);
} else if (parity == parity_space) {
options.c_cflag |= (PARENB | CMSPAR);
options.c_cflag &= (tcflag_t) ~(PARODD);
}
#else
// CMSPAR is not defined on OSX. So do not support mark or space parity.
else if (parity == parity_mark || parity == parity_space) {
log_debug("OS does not support mark or space parity");
}
#endif // ifdef CMSPAR
else {
log_debug("invalid parity");
}
// setup flow control
if (flowcontrol == flowcontrol_none) {
xonxoff = FALSE;
rtscts = FALSE;
}
if (flowcontrol == flowcontrol_software) {
xonxoff = TRUE;
rtscts = FALSE;
}
if (flowcontrol == flowcontrol_hardware) {
xonxoff = FALSE;
rtscts = TRUE;
}
// xonxoff
#ifdef IXANY
if (xonxoff)
options.c_iflag |= (IXON | IXOFF); //|IXANY)
else
options.c_iflag &= (tcflag_t) ~(IXON | IXOFF | IXANY);
#else
if (xonxoff)
options.c_iflag |= (IXON | IXOFF);
else
options.c_iflag &= (tcflag_t) ~(IXON | IXOFF);
#endif
// rtscts
#ifdef CRTSCTS
if (rtscts)
options.c_cflag |= (CRTSCTS);
else
options.c_cflag &= (unsigned long)~(CRTSCTS);
#elif defined CNEW_RTSCTS
if (rtscts)
options.c_cflag |= (CNEW_RTSCTS);
else
options.c_cflag &= (unsigned long)~(CNEW_RTSCTS);
#else
#error "OS Support seems wrong."
#endif
// http://www.unixwiz.net/techtips/termios-vmin-vtime.html
// this basically sets the read call up to be a polling read,
// but we are using select to ensure there is data available
// to read before each call, so we should never needlessly poll
options.c_cc[VMIN] = 0;
options.c_cc[VTIME] = 0;
// activate settings
tcsetattr(dev, TCSANOW, &options);
// Update byte_time based on the new settings.
uint32_t bit_time_ns = 1e9 / baudrate;
byte_time_ns = bit_time_ns * (1 + bytesize + parity + stopbits);
// Compensate for the stopbits_one_point_five enum being equal to int 3,
// and not 1.5.
if (stopbits == stopbits_one_point_five) {
byte_time_ns += ((1.5 - stopbits_one_point_five) * bit_time_ns);
}
(void)bit_time_ns;
return RET_OK;
}
ret_t serial_iflush(serial_handle_t handle) {
serial_dev_t dev = serial_handle_get_dev(handle);
return tcflush(dev, TCIFLUSH) == 0 ? RET_OK : RET_FAIL;
}
ret_t serial_oflush(serial_handle_t handle) {
serial_dev_t dev = serial_handle_get_dev(handle);
return tcflush(dev, TCOFLUSH) == 0 ? RET_OK : RET_FAIL;
}
ret_t serial_close(serial_handle_t handle) {
serial_dev_t dev = serial_handle_get_dev(handle);
serial_iflush(handle);
serial_oflush(handle);
tcsetattr(dev, TCSANOW, (struct termios*)handle->old_options);
TKMEM_FREE(handle->old_options);
close(dev);
memset(handle, 0x0, sizeof(*handle));
TKMEM_FREE(handle);
return RET_OK;
}
int serial_handle_get_fd(serial_handle_t handle) {
return handle->dev;
}
serial_dev_t serial_handle_get_dev(serial_handle_t handle) {
return handle->dev;
}
int32_t serial_read(serial_handle_t handle, uint8_t* buff, uint32_t max_size) {
int fd = serial_handle_get_fd(handle);
return read(fd, buff, max_size);
}
int32_t serial_write(serial_handle_t handle, const uint8_t* buff, uint32_t max_size) {
int fd = serial_handle_get_fd(handle);
return write(fd, buff, max_size);
}
ret_t serial_wait_for_data(serial_handle_t handle, uint32_t timeout_ms) {
int fd = serial_handle_get_fd(handle);
return tk_socket_wait_for_data(fd, timeout_ms);
}
#endif /*WIN32*/
stopbits_t serial_stopbits_from_str(const char* str) {
if (str == NULL) {
return stopbits_one;
}
if (strstr(str, "two") != NULL || strchr(str, '2') != NULL) {
return stopbits_two;
} else if (strstr(str, "five") != NULL || strchr(str, '5') != NULL) {
return stopbits_one_point_five;
} else {
return stopbits_one;
}
}
flowcontrol_t serial_flowcontrol_from_str(const char* str) {
if (str == NULL) {
return flowcontrol_none;
}
if (strstr(str, "soft") != NULL) {
return flowcontrol_software;
} else if (strstr(str, "hard") != NULL) {
return flowcontrol_hardware;
} else {
return flowcontrol_none;
}
}
parity_t serial_parity_from_str(const char* str) {
if (str == NULL) {
return parity_none;
}
if (strstr(str, "odd") != NULL) {
return parity_odd;
} else if (strstr(str, "even") != NULL) {
return parity_even;
} else if (strstr(str, "mark") != NULL) {
return parity_mark;
} else if (strstr(str, "space") != NULL) {
return parity_space;
} else {
return parity_none;
}
}
bytesize_t serial_bytesize_from_str(const char* str) {
if (str == NULL) {
return eightbits;
}
if (strstr(str, "eight") != NULL || strchr(str, '8') != NULL) {
return eightbits;
} else if (strstr(str, "seven") != NULL || strchr(str, '7') != NULL) {
return sevenbits;
} else if (strstr(str, "six") != NULL || strchr(str, '6') != NULL) {
return sixbits;
} else if (strstr(str, "five") != NULL || strchr(str, '5') != NULL) {
return fivebits;
}
return eightbits;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_default.h
|
/**
* File: object_default.h
* Author: AWTK Develop Team
* Brief: default object
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-10 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_DEFAULT_H
#define TK_OBJECT_DEFAULT_H
#include "tkc/object.h"
#include "tkc/darray.h"
#include "tkc/named_value.h"
BEGIN_C_DECLS
/**
* @class object_default_t
* @parent tk_object_t
* @annotation ["scriptable"]
*
* 对象接口的缺省实现。
*
* 通用当作 map 数据结构使用，内部用有序数组保存所有属性，因此可以快速查找指定名称的属性。
*
* 示例
*
*```c
* // 创建默认对象
* tk_object_t *obj = object_default_create();
*
* // 设置属性
* tk_object_set_prop_str(obj, "name", "awplc");
* tk_object_set_prop_int(obj, "age", 18);
* tk_object_set_prop_double(obj, "weight", 60.5);
*
* // 获取属性
* ENSURE(tk_str_eq(tk_object_get_prop_str(obj, "name"), "awplc"));
* ENSURE(tk_object_get_prop_int(obj, "age", 0) == 18);
* ENSURE(tk_object_get_prop_double(obj, "weight", 0) == 60.5);
*
* // 遍历属性
* tk_object_foreach_prop(obj, visit_obj, NULL);
*
* // 释放对象
* TK_OBJECT_UNREF(obj);
*```
*/
typedef struct _object_default_t {
tk_object_t object;
/*private*/
darray_t props;
bool_t enable_path;
/*设置属性值不改变属性的类型*/
bool_t keep_prop_type;
bool_t name_case_insensitive;
} object_default_t;
/**
* @method object_default_create
*
* 创建对象。
*
* @annotation ["constructor", "scriptable", "gc"]
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_default_create(void);
/**
* @method object_default_create_ex
*
* 创建对象。
*
* @annotation ["constructor", "scriptable", "gc"]
* @param {bool_t} enable_path 是否支持按路径访问属性。
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_default_create_ex(bool_t enable_path);
/**
* @method object_default_clone
*
* 克隆对象。
*
* @annotation ["constructor"]
* @param {object_default_t*} o 被克隆的对象。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_default_clone(object_default_t* o);
/**
* @method object_default_unref
*
* for script gc
* @param {tk_object_t*} obj 对象。
*
* @annotation ["deconstructor", "scriptable", "gc"]
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_default_unref(tk_object_t* obj);
/**
* @method object_default_clear_props
*
* 清除全部属性。
*
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t object_default_clear_props(tk_object_t* obj);
/**
* @method object_default_set_keep_prop_type
* 设置属性值时不改变属性的类型。
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {bool_t} keep_prop_type 不改变属性的类型。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_default_set_keep_prop_type(tk_object_t* obj, bool_t keep_prop_type);
/**
* @method object_default_set_name_case_insensitive
* 设置属性名是否大小写不敏感。
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {bool_t} name_case_insensitive 属性名是否大小写不敏感。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_default_set_name_case_insensitive(tk_object_t* obj, bool_t name_case_insensitive);
/**
* @method object_default_find_prop
*
* 查找满足条件的属性，并返回它的值。
*
* @param {tk_object_t*} obj 对象。
* @param {tk_compare_t} cmp 比较函数。
* @param {const void*} data 要比较的数据。
*
* @return {value_t*} 返回属性的值。
*
*/
value_t* object_default_find_prop(tk_object_t* obj, tk_compare_t cmp, const void* data);
/**
* @method object_default_cast
* 转换为object_default对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_default对象。
*
* @return {object_default_t*} object_default对象。
*/
object_default_t* object_default_cast(tk_object_t* obj);
#define OBJECT_DEFAULT(obj) object_default_cast(obj)
#define OBJECT_DEFAULT_TYPE "object_default"
END_C_DECLS
#endif /*TK_OBJECT_DEFAULT_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/fscript.h
|
/**
* File: fscript.h
* Author: AWTK Develop Team
* Brief: a simple functional script language
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
*/
/**
* History:
* ================================================================
* 2020-11-09 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FSCRIPTS_H
#define TK_FSCRIPTS_H
#include "tkc/str.h"
#include "tkc/object.h"
#include "tkc/general_factory.h"
BEGIN_C_DECLS
#define FSCRIPT_MAX_ARGS 128
#define FSCRIPT_STR_CAPACITY 64
/**
* @class fscript_args_t
*
* 扩展函数的参数。
*
*/
typedef struct _fscript_args_t {
/**
* @property {uint16_t} size
* @annotation ["readable"]
* 参数个数。
*/
uint16_t size;
/**
* @property {uint16_t} capacity
* @annotation ["readable"]
* 目前最大容量。
*/
uint16_t capacity;
/**
* @property {value_t*} args
* @annotation ["readable"]
* 参数列表。
*/
value_t* args;
} fscript_args_t;
struct _fscript_func_call_t;
typedef struct _fscript_func_call_t fscript_func_call_t;
/**
* @class fscript_parser_error_t
*
* 解析错误信息。
*
*/
typedef struct _fscript_parser_error_t {
/**
* @property {int} row
* @annotation ["readable"]
* 出现错误的代码行。
*/
int row;
/**
* @property {int} col
* @annotation ["readable"]
* 出现错误的代码列。
*/
int col;
/**
* @property {int} offset
* @annotation ["readable"]
* 出现错误的代码偏移。
*/
int offset;
/**
* @property {char*} message
* @annotation ["readable"]
* 错误信息。
*/
char* message;
/**
* @property {char*} token
* @annotation ["readable"]
* 当前的token。
*/
char* token;
} fscript_parser_error_t;
/**
* @method fscript_parser_error_deinit
* 释放error对象中的资源。
*
* @param {fscript_parser_error_t*} error 解析错误信息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_parser_error_deinit(fscript_parser_error_t* error);
struct _fscript_t;
struct _fscript_hooks_t;
typedef struct _fscript_t fscript_t;
typedef struct _fscript_hooks_t fscript_hooks_t;
typedef ret_t (*fscript_on_error_t)(void* ctx, fscript_t* fscript);
typedef ret_t (*fscript_func_t)(fscript_t* fscript, fscript_args_t* args, value_t* v);
/**
* @class fscript_t
* @annotation ["fake"]
*
* 一个简易的函数式脚本引擎。
* 用法请参考：https://github.com/zlgopen/awtk/blob/master/docs/fscript.md
*
*/
struct _fscript_t {
/**
* @property {str_t} str
* @annotation ["readable"]
* C语言实现函数可以使用这个变量，可以有效避免内存分配。
*/
str_t str;
/**
* @property {tk_object_t*} obj
* @annotation ["readable"]
* 脚本执行上下文。
*/
tk_object_t* obj;
/**
* @property {ret_t} error_code
* @annotation ["readable"]
* 运行时错误码。
*/
ret_t error_code;
/**
* @property {char*} error_message
* @annotation ["readable"]
* 运行时错误信息。
*/
char* error_message;
/**
* @property {int32_t} error_row
* @annotation ["readable"]
* 运行时错误的行号。
*/
int32_t error_row;
/**
* @property {int32_t} error_col
* @annotation ["readable"]
* 运行时错误的列号。
*/
int32_t error_col;
/**
* @property {uint16_t} lines
* @annotation ["readable"]
* 代码总行数。
*/
uint16_t lines;
/*private*/
char* code_id;
fscript_func_call_t* curr;
fscript_func_call_t* first;
fscript_func_call_t* error_func;
bool_t breaked;
bool_t continued;
bool_t returned;
bool_t rerun;
uint8_t loop_count;
/*预解析的临时变量*/
darray_t* symbols;
/*函数局部变量和参数*/
darray_t* locals;
/*脚本定义的函数*/
tk_object_t* funcs_def;
const fscript_hooks_t* hooks;
void* on_error_ctx;
fscript_on_error_t on_error;
fscript_func_t print;
};
/**
* @method fscript_create
* 创建引擎对象，并解析代码。
* @param {tk_object_t*} obj 脚本执行上下文。
* @param {const char*} script 脚本代码。
*
* @return {fscript_t*} 返回fscript对象。
*/
fscript_t* fscript_create(tk_object_t* obj, const char* script);
/**
* @method fscript_create_ex
* 创建引擎对象，并解析代码。
* @param {tk_object_t*} obj 脚本执行上下文。
* @param {const char*} script 脚本代码。
* @param {bool_t} keep_func_name 是否在func_call结构后保存函数名。
*
* @return {fscript_t*} 返回fscript对象。
*/
fscript_t* fscript_create_ex(tk_object_t* obj, const char* script, bool_t keep_func_name);
/**
* @method fscript_init
* 初始化引擎对象，并解析代码。
* @param {fscript_t*} fscript 初始化 fscript 对象。
* @param {tk_object_t*} obj 脚本执行上下文。
* @param {const char*} script 脚本代码。
* @param {const char*} first_call_name 第一个函数的名字。
* @param {bool_t} keep_func_name 是否在func_call结构后保存函数名。
*
* @return {fscript_t*} 返回fscript对象。
*/
fscript_t* fscript_init(fscript_t* fscript, tk_object_t* obj, const char* script,
const char* first_call_name, bool_t keep_func_name);
/**
* @method fscript_syntax_check
* 解析代码，分析是否有语法错误。
*
* 示例：
* ```c
* fscript_parser_error_t error;
* fscript_syntax_check(obj, "1+1", &error);
* fscript_parser_error_deinit(&error);
*```
*
* @param {tk_object_t*} obj 脚本执行上下文。
* @param {const char*} script 脚本代码。
* @param {fscript_parser_error_t*} error 用于返回错误信息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_syntax_check(tk_object_t* obj, const char* script, fscript_parser_error_t* error);
/**
* @method fscript_exec
* 执行解析后的代码。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {value_t*} result 执行结果(调用者需要用value_reset函数清除result)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_exec(fscript_t* fscript, value_t* result);
/**
* @method fscript_reload
* 重新加载代码。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {const char*} script 脚本代码。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_reload(fscript_t* fscript, const char* script);
/**
* @method fscript_set_error
* 用于扩展函数设置遇到的错误。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {ret_t} code 错误码。
* @param {const char*} func 函数名。
* @param {const char*} message 错误消息。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_error(fscript_t* fscript, ret_t code, const char* func, const char* message);
/**
* @method fscript_set_on_error
* 设置错误处理函数。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {fscript_on_error_t} on_error 错误处理函数。
* @param {void*} ctx 错误处理函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_on_error(fscript_t* fscript, fscript_on_error_t on_error, void* ctx);
/**
* @method fscript_set_print_func
* 设置打印日志的函数。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {fscript_func_t} print 打印日志的函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_print_func(fscript_t* fscript, fscript_func_t print);
/**
* @method fscript_deinit
* 清除引擎对象的数据。
* @param {fscript_t*} fscript 脚本引擎对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_deinit(fscript_t* fscript);
/**
* @method fscript_destroy
* 销毁引擎对象。
* @param {fscript_t*} fscript 脚本引擎对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_destroy(fscript_t* fscript);
/**
* @method fscript_clean
* 使用lua或其它脚本来运行fscript时，本函数用于清理不必要的数据结构。
* @param {fscript_t*} fscript 脚本引擎对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_clean(fscript_t* fscript);
/**
* @method fscript_eval
* 执行一段脚本。
* @param {tk_object_t*} obj 脚本执行上下文。
* @param {const char*} script 脚本代码。
* @param {value_t*} result 执行结果(调用者需要用value_reset函数清除result)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_eval(tk_object_t* obj, const char* script, value_t* result);
/**
* @method fscript_global_init
* 全局初始化。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_global_init(void);
/**
* @method fscript_set_global_object
* 用于替换默认的全局对象。
* >仅限于在系统初始化时调用。
* @param {tk_object_t*} obj 全局对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_global_object(tk_object_t* obj);
/**
* @method fscript_register_func
* 注册全局自定义函数。
* @param {const char*} name 函数名(无需加函数前缀)。
* @param {fscript_func_t} func 函数指针。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_register_func(const char* name, fscript_func_t func);
/**
* @method fscript_register_event
* 注册自定义事件。
* @param {const char*} name 事件名。
* @param {uint32_t} etype 事件的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_register_event(const char* name, uint32_t etype);
/**
* @method fscript_register_const_value
* 注册常量。
* @param {const char*} name 常量名。
* @param {const value_t*} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_register_const_value(const char* name, const value_t* value);
/**
* @method fscript_register_const_int
* 注册整数常量。
* @param {const char*} name 常量名。
* @param {int} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_register_const_int(const char* name, int value);
/**
* @method fscript_register_const_double
* 注册浮点数常量。
* @param {const char*} name 常量名。
* @param {double} value 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_register_const_double(const char* name, double value);
/**
* @method fscript_register_funcs
* 注册全局自定义函数。
* @param {const general_factory_table_t*} table 函数表。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_register_funcs(const general_factory_table_t* table);
/**
* @method fscript_global_deinit
* 全局释放。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_global_deinit(void);
/**
* @method tk_expr_eval
* 对fscript的简单包装。
*
* @param {const char*} expr 表达式。
*
* @return {double} 返回表达式的值。
*/
double tk_expr_eval(const char* expr);
/**
* @method fscript_get_global_object
* 获取fscript的全局对象。
*
* @return {tk_object_t*} 返回fscript的全局对象。
*/
tk_object_t* fscript_get_global_object(void);
/**
* @class fscript_func_call_t
*
* 函数描述。
*
*/
struct _fscript_func_call_t {
/**
* @property {void*} ctx
* @annotation ["readable"]
* 函数需要的上下文。
* >目前主要保持自定义函数的实现。
*/
void* ctx;
/**
* @property {uint16_t} row
* @annotation ["readable"]
* 对应源代码行号。
*/
uint16_t row;
/**
* @property {uint16_t} col
* @annotation ["readable"]
* 对应源代码列号。
*/
uint16_t col;
/**
* @property {fscript_func_t} func
* @annotation ["readable"]
* 函数指针。
*/
fscript_func_t func;
/*private*/
fscript_args_t args;
fscript_func_call_t* next;
};
/*注册自定义函数时，属性名的前缀。*/
#define STR_FSCRIPT_FUNCTION_PREFIX "function."
/*用于扩展函数里检查参数*/
#define FSCRIPT_FUNC_CHECK(predicate, code) \
if (!(predicate)) { \
fscript_set_error(fscript, code, __FUNCTION__, "" #predicate " not satisfied."); \
return code; \
}
#define FSCRIPT_STR_GLOBAL_PREFIX "global."
#define FSCRIPT_GLOBAL_PREFIX_LEN 7
#define VALUE_TYPE_FSCRIPT_ID VALUE_TYPE_ID
#define VALUE_TYPE_FSCRIPT_FUNC VALUE_TYPE_FUNC
typedef ret_t (*fscript_on_init_t)(fscript_t* fscript, const char* code);
typedef ret_t (*fscript_on_deinit_t)(fscript_t* fscript);
typedef ret_t (*fscript_before_exec_t)(fscript_t* fscript);
typedef ret_t (*fscript_after_exec_t)(fscript_t* fscript);
typedef ret_t (*fscript_set_var_t)(fscript_t* fscript, const char* name, const value_t* v);
typedef ret_t (*fscript_exec_func_t)(fscript_t* fscript, const char* name,
fscript_func_call_t* iter, value_t* result);
/**
* @method fscript_set_var_default
* 设置变量的默认实现。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {const char*} name 变量名。
* @param {const value_t*} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_var_default(fscript_t* fscript, const char* name, const value_t* value);
/**
* @method fscript_exec_func_default
* 执行函数的默认实现。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {fscript_func_call_t*} iter 当前函数。
* @param {value_t*} result 返回结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_exec_func_default(fscript_t* fscript, fscript_func_call_t* iter, value_t* result);
struct _fscript_hooks_t {
fscript_on_init_t on_init;
fscript_on_deinit_t on_deinit;
fscript_set_var_t set_var;
fscript_exec_func_t exec_func;
fscript_before_exec_t before_exec;
fscript_after_exec_t after_exec;
};
/**
* @method fscript_set_hooks
* 设置回调函数。
* @param {const fscript_hooks_t*} hooks 回调函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_hooks(const fscript_hooks_t* hooks);
/**
* @method fscript_set_self_hooks
* 设置 fscript 对象的回调函数。
* @param {fscript_t*} fscript fscript 对象。
* @param {const fscript_hooks_t*} hooks 回调函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_set_self_hooks(fscript_t* fscript, const fscript_hooks_t* hooks);
/**
* @method fscript_ensure_locals
* export for debugger
* @param {fscript_t*} fscript 脚本引擎对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t fscript_ensure_locals(fscript_t* fscript);
/**
* @method fscript_find_func
* 查找函数。
* @param {fscript_t*} fscript 脚本引擎对象。
* @param {const char*} name 函数名。
* @param {uint32_t} size 函数名长度。
*
* @return {fscript_func_t} 返回函数指针，NULL表示失败。
*/
fscript_func_t fscript_find_func(fscript_t* fscript, const char* name, uint32_t size);
/**
* @method fscript_find_event
* 查找事件。
* @param {const char*} name 事件名。
*
* @return {uint32_t} 返回事件的值。
*/
uint32_t fscript_find_event(const char* name);
/**
* @method fscript_get_code_id
* 获取code_id。
* @param {const char*} str 代码。
*
* @return {char*} 返回code_id，有调用者释放返回的字符串。
*/
char* fscript_get_code_id(const char* str);
/**
* @class fscript_function_def_t
* 脚本函数定义。
*
*/
typedef struct _fscript_function_def_t {
/**
* @property {char*} name
* @annotation ["readable"]
* 函数名。
*/
char* name;
/**
* @property {darray_t} params
* @annotation ["readable"]
* 参数列表。
*/
darray_t params;
/**
* @property {fscript_func_call_t*} body
* @annotation ["readable"]
* 函数体。
*/
fscript_func_call_t* body;
} fscript_function_def_t;
#define FSCRIPT_CONSTS_PREFIX "fconsts."
END_C_DECLS
#endif /*TK_FSCRIPTS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/data_reader_http.h
|
/**
* File: data_reader_http.h
* Author: AWTK Develop Team
* Brief: data_reader http
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License http for more details.
*
*/
/**
* History:
* ================================================================
* 2023-12-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATA_READER_HTTP_H
#define TK_DATA_READER_HTTP_H
#include "tkc/data_reader.h"
BEGIN_C_DECLS
/**
* @class data_reader_http_t
* @parent data_reader_t
* @annotation ["fake"]
* 基于HTTP/HTTPS实现的 data_reader。通过 data_reader_factory 创建 reader 时，URL的格式如下(请用函数data_reader_http_build_url生成)：
*
* ```
* http://t.weather.sojson.com/api/weather/city/101030100
* https://restapi.amap.com/v3/weather/weatherInfo?city=110101&key=%3C%E7%94%A8%E6%88%B7key%3E
* ```
*/
/**
* @method data_reader_http_create
* 创建基于文件的data reader。
* > 不要直接调用，而是注册到 data\_reader\_factory后，通过data\_reader\_factory调用。
* @annotation ["constructor"]
*
* @param {const char*} url URL。
*
* @return {data_reader_t*} 返回data reader对象。
*/
data_reader_t* data_reader_http_create(const char* url);
END_C_DECLS
#endif /*TK_DATA_READER_HTTP_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_idle.c
|
/**
* File: event_source_idle.h
* Author: AWTK Develop Team
* Brief: event source idle
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#include "tkc/event_source_idle.h"
static const object_vtable_t s_event_source_idle_vtable = {
.type = "event_source_idle", .desc = "event_source_idle", .size = sizeof(event_source_idle_t)};
static int32_t event_source_idle_get_fd(event_source_t* source) {
return -1;
}
static ret_t event_source_idle_check(event_source_t* source) {
return RET_OK;
}
static ret_t event_source_idle_dispatch(event_source_t* source) {
event_source_idle_t* event_source_idle = EVENT_SOURCE_IDLE(source);
return idle_manager_dispatch(event_source_idle->idle_manager);
}
uint32_t event_source_idle_get_wakeup_time(event_source_t* source) {
event_source_idle_t* event_source_idle = EVENT_SOURCE_IDLE(source);
uint32_t nr = idle_manager_count(event_source_idle->idle_manager);
return nr > 0 ? 0 : 0xffff;
}
event_source_t* event_source_idle_create(idle_manager_t* idle_manager) {
tk_object_t* obj = NULL;
event_source_t* event_source = NULL;
event_source_idle_t* event_source_idle = NULL;
return_value_if_fail(idle_manager != NULL, NULL);
obj = tk_object_create(&s_event_source_idle_vtable);
event_source = EVENT_SOURCE(obj);
event_source_idle = EVENT_SOURCE_IDLE(obj);
return_value_if_fail(event_source_idle != NULL, NULL);
event_source_idle->idle_manager = idle_manager;
event_source->check = event_source_idle_check;
event_source->get_fd = event_source_idle_get_fd;
event_source->dispatch = event_source_idle_dispatch;
event_source->get_wakeup_time = event_source_idle_get_wakeup_time;
return event_source;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_compositor.c
|
/**
* File: object_compositor.c
* Author: AWTK Develop Team
* Brief: compositor two objects into one
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-20 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "tkc/object_compositor.h"
static ret_t object_compositor_on_destroy(tk_object_t* obj) {
emitter_t* obj1 = NULL;
emitter_t* obj2 = NULL;
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
obj1 = EMITTER(o->obj1);
obj2 = EMITTER(o->obj2);
return_value_if_fail(obj1 != NULL && obj2 != NULL, RET_BAD_PARAMS);
emitter_off_by_ctx(obj1, o);
emitter_off_by_ctx(obj2, o);
TK_OBJECT_UNREF(o->obj1);
TK_OBJECT_UNREF(o->obj2);
return RET_OK;
}
static int32_t object_compositor_compare(tk_object_t* obj, tk_object_t* other) {
return strcmp(obj->name, other->name);
}
static ret_t object_compositor_remove_prop(tk_object_t* obj, const char* name) {
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_object_remove_prop(o->obj1, name) == RET_OK) {
return RET_OK;
}
return tk_object_remove_prop(o->obj2, name);
}
static ret_t object_compositor_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_object_set_prop(o->obj1, name, v) == RET_OK) {
return RET_OK;
}
return tk_object_set_prop(o->obj2, name, v);
}
static ret_t object_compositor_get_prop(tk_object_t* obj, const char* name, value_t* v) {
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_object_get_prop(o->obj1, name, v) == RET_OK) {
return RET_OK;
}
return tk_object_get_prop(o->obj2, name, v);
}
static ret_t object_compositor_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
ret_t ret = RET_OK;
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
ret = tk_object_foreach_prop(o->obj1, on_prop, ctx);
if (ret != RET_STOP) {
ret = tk_object_foreach_prop(o->obj2, on_prop, ctx);
}
return ret;
}
static bool_t object_compositor_can_exec(tk_object_t* obj, const char* name, const char* args) {
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, FALSE);
if (tk_object_can_exec(o->obj1, name, args)) {
return TRUE;
}
return tk_object_can_exec(o->obj2, name, args);
}
static ret_t object_compositor_exec(tk_object_t* obj, const char* name, const char* args) {
object_compositor_t* o = OBJECT_COMPOSITOR(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_object_exec(o->obj1, name, args) == RET_OK) {
return RET_OK;
}
return tk_object_exec(o->obj2, name, args);
}
static const object_vtable_t s_object_compositor_vtable = {
.type = OBJECT_COMPOSITOR_TYPE,
.desc = OBJECT_COMPOSITOR_TYPE,
.size = sizeof(object_compositor_t),
.is_collection = FALSE,
.on_destroy = object_compositor_on_destroy,
.exec = object_compositor_exec,
.can_exec = object_compositor_can_exec,
.compare = object_compositor_compare,
.get_prop = object_compositor_get_prop,
.set_prop = object_compositor_set_prop,
.remove_prop = object_compositor_remove_prop,
.foreach_prop = object_compositor_foreach_prop};
static ret_t object_compositor_forward_events(void* ctx, event_t* e) {
object_compositor_t* o = OBJECT_COMPOSITOR(ctx);
emitter_dispatch_simple_event(EMITTER(o), e->type);
return RET_OK;
}
tk_object_t* object_compositor_create(tk_object_t* obj1, tk_object_t* obj2) {
tk_object_t* o = NULL;
object_compositor_t* wrapper = NULL;
return_value_if_fail(obj1 != NULL && obj2 != NULL, NULL);
o = tk_object_create(&s_object_compositor_vtable);
wrapper = OBJECT_COMPOSITOR(o);
return_value_if_fail(wrapper != NULL, NULL);
wrapper->obj1 = tk_object_ref(obj1);
emitter_on(EMITTER(obj1), EVT_ITEMS_CHANGED, object_compositor_forward_events, o);
emitter_on(EMITTER(obj1), EVT_PROPS_CHANGED, object_compositor_forward_events, o);
wrapper->obj2 = tk_object_ref(obj2);
emitter_on(EMITTER(obj2), EVT_ITEMS_CHANGED, object_compositor_forward_events, o);
emitter_on(EMITTER(obj2), EVT_PROPS_CHANGED, object_compositor_forward_events, o);
return o;
}
object_compositor_t* object_compositor_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_compositor_vtable, NULL);
return (object_compositor_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/date_time.h
|
/**
* File: date_time.h
* Author: AWTK Develop Team
* Brief: date time
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-11-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_DATE_TIME_H
#define TK_DATE_TIME_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class date_time_t
* @annotation ["scriptable"]
* 日期时间。
*
*> 在嵌入式平台中，在系统初始时，需要调用date\_time\_global\_init设置实际获取/设置系统时间的函数。
*
*/
typedef struct _date_time_t {
/**
* @property {int32_t} second
* @annotation ["readable", "scriptable"]
* 秒(0 - 59)。
*/
int32_t second;
/**
* @property {int32_t} minute
* @annotation ["readable", "scriptable"]
* 分(0 - 59)。
*/
int32_t minute;
/**
* @property {int32_t} hour
* @annotation ["readable", "scriptable"]
* 时(0 - 23)。
*/
int32_t hour; /* hours (0 - 23) */
/**
* @property {int32_t} day
* @annotation ["readable", "scriptable"]
* 日(1-31)。
*/
int32_t day;
/**
* @property {int32_t} wday
* @annotation ["readable", "scriptable"]
* 星期几(0-6, Sunday = 0)。
*/
int32_t wday;
/**
* @property {int32_t} month
* @annotation ["readable", "scriptable"]
* 月(1-12)。
*/
int32_t month;
/**
* @property {int32_t} year
* @annotation ["readable", "scriptable"]
* 年。
*/
int32_t year;
} date_time_t;
/**
* @method date_time_create
* 创建date_time对象，并初始为当前日期和时间(一般供脚本语言中使用)。
* @annotation ["constructor", "scriptable", "gc"]
*
* @return {date_time_t*} 返回date_time对象。
*/
date_time_t* date_time_create(void);
/**
* @method date_time_init
* 初始为当前日期和时间。
* @param {date_time_t*} dt date_time对象。
*
* @return {date_time_t*} 返回date_time对象。
*/
date_time_t* date_time_init(date_time_t* dt);
/**
* @method date_time_parse_time
* 解析时间。
* @param {date_time_t*} dt date_time对象。
* @param {const char*} str 时间字符串。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_parse_time(date_time_t* dt, const char* str);
/**
* @method date_time_parse_date
* 解析日期。
* @param {date_time_t*} dt date_time对象。
* @param {const char*} str 日期字符串。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_parse_date(date_time_t* dt, const char* str);
/**
* @method date_time_parse_date_time
* 解析日期和时间。
* @param {date_time_t*} dt date_time对象。
* @param {const char*} str 日期和时间字符串。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_parse_date_time(date_time_t* dt, const char* str);
/**
* @method date_time_set_year
* 设置年。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {uint32_t} year 年。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set_year(date_time_t* dt, uint32_t year);
/**
* @method date_time_set_month
* 设置月。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {uint32_t} month 月。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set_month(date_time_t* dt, uint32_t month);
/**
* @method date_time_set_day
* 设置日。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {uint32_t} day 日。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set_day(date_time_t* dt, uint32_t day);
/**
* @method date_time_set_hour
* 设置小时。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {uint32_t} hour 小时。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set_hour(date_time_t* dt, uint32_t hour);
/**
* @method date_time_set_minute
* 设置分钟。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {uint32_t} minute 分钟。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set_minute(date_time_t* dt, uint32_t minute);
/**
* @method date_time_set_second
* 设置秒。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {uint32_t} second 秒。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set_second(date_time_t* dt, uint32_t second);
/**
* @method date_time_set
* 设置当前时间。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_set(date_time_t* dt);
/**
* @method date_time_from_time
* 从time转换而来(按GMT转换)。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {int64_t} time 时间。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_from_time(date_time_t* dt, int64_t time);
/**
* @method date_time_to_time
* 转换成time(按GMT转换)。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
*
* @return {int64_t} 返回time。
*/
int64_t date_time_to_time(date_time_t* dt);
/**
* @method date_time_add_delta
* 加上一个偏移量(s)。
*
* @annotation ["scriptable"]
* @param {date_time_t*} dt date_time对象。
* @param {int64_t} delta 偏移量(s)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_add_delta(date_time_t* dt, int64_t delta);
/**
* @method date_time_is_leap
* 是否是闰年。
*
* @annotation ["scriptable", "static"]
* @param {uint32_t} year 年份。
*
* @return {bool_t} 返回TRUE表示是，否则表示否。
*/
bool_t date_time_is_leap(uint32_t year);
/**
* @method date_time_get_days
* 获取指定年份月份的天数。
*
* @annotation ["scriptable", "static"]
* @param {uint32_t} year 年份。
* @param {uint32_t} month 月份(1-12)。
*
* @return {int32_t} 返回大于0表示天数，否则表示失败。
*/
int32_t date_time_get_days(uint32_t year, uint32_t month);
/**
* @method date_time_get_wday
* 获取指定日期是周几(0-6, Sunday = 0)。。
*
* @annotation ["scriptable", "static"]
* @param {uint32_t} year 年份。
* @param {uint32_t} month 月份(1-12)。
* @param {uint32_t} day 日(1-31)。
*
* @return {int32_t} 返回大于等于0表示周几(0-6)，否则表示失败。
*/
int32_t date_time_get_wday(uint32_t year, uint32_t month, uint32_t day);
/**
* @method date_time_get_month_name
* 获取指定月份的英文名称(简写)。
*
* @annotation ["scriptable", "static"]
* @param {uint32_t} month 月份(1-12)。
*
* @return {const char*} 返回指定月份的英文名称(简写)。
*/
const char* date_time_get_month_name(uint32_t month);
/**
* @method date_time_get_wday_name
* 获取周几的英文名称(简写)。
*
* @annotation ["scriptable", "static"]
* @param {uint32_t} wday 星期几(0-6, Sunday = 0)。
*
* @return {const char*} 返回指定周几的英文名称(简写)。
*/
const char* date_time_get_wday_name(uint32_t wday);
/**
* @method date_time_destroy
* 销毁date_time对象(一般供脚本语言中使用)。
*
* @annotation ["deconstructor", "scriptable", "gc"]
* @param {date_time_t*} dt date_time对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_destroy(date_time_t* dt);
typedef ret_t (*date_time_get_now_t)(date_time_t* dt);
typedef ret_t (*date_time_set_now_t)(date_time_t* dt);
typedef ret_t (*date_time_from_time_t)(date_time_t* dt, uint64_t time);
typedef uint64_t (*date_time_to_time_t)(date_time_t* dt);
typedef struct _date_time_vtable_t {
date_time_get_now_t get_now;
date_time_set_now_t set_now;
date_time_from_time_t from_time;
date_time_to_time_t to_time;
} date_time_vtable_t;
/**
* @method date_time_global_init_ex
* 时间日期全局初始化。
*
* > 嵌入式平台需要提供并设置获取当前日期和时间的函数，否则相关的功能(如时钟控件)将无法正常工作。
*
* @param {const date_time_vtable_t*} vt 日期和时间的相关函数的实现。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t date_time_global_init_ex(const date_time_vtable_t* vt);
/*deprecated*/
ret_t date_time_set_impl(date_time_get_now_t date_time_get_now);
ret_t date_time_global_init(date_time_get_now_t get, date_time_set_now_t set);
END_C_DECLS
#endif /*TK_DATE_TIME_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/iostream.h
|
/**
* File: tk_iostream.h
* Author: AWTK Develop Team
* Brief: input/ouput stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_TK_IOSTREAM_H
#define TK_TK_IOSTREAM_H
#include "tkc/istream.h"
#include "tkc/ostream.h"
#include "tkc/stream_const.h"
BEGIN_C_DECLS
struct _tk_iostream_t;
typedef struct _tk_iostream_t tk_iostream_t;
typedef tk_istream_t* (*tk_iostream_get_istream_t)(tk_iostream_t* stream);
typedef tk_ostream_t* (*tk_iostream_get_ostream_t)(tk_iostream_t* stream);
/**
* @class tk_iostream_t
* @parent tk_object_t
*
* 输入输出流的接口。
*
*/
struct _tk_iostream_t {
tk_object_t object;
tk_iostream_get_istream_t get_istream;
tk_iostream_get_ostream_t get_ostream;
};
/**
* @method tk_iostream_get_istream
*
* 获取输入流对象(不再使用时，无需UNREF返回的对象)。
*
* @param {tk_iostream_t*} stream iostream对象。
*
* @return {tk_istream_t*} 返回输入流对象。
*
*/
tk_istream_t* tk_iostream_get_istream(tk_iostream_t* stream);
/**
* @method tk_iostream_get_ostream
*
* 获取输出流对象(不再使用时，无需UNREF返回的对象)。
*
* @param {tk_iostream_t*} stream iostream对象。
*
* @return {tk_ostream_t*} 返回输出流对象。
*
*/
tk_ostream_t* tk_iostream_get_ostream(tk_iostream_t* stream);
/**
* @method tk_iostream_read
*
* 读取数据。
*
* @param {tk_iostream_t*} stream iostream对象。
* @param {void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
*
* @return {int32_t} 返回负数表示读取失败，否则返回实际读取数据的长度。
*
*/
int32_t tk_iostream_read(tk_iostream_t* stream, void* buff, uint32_t max_size);
/**
* @method tk_iostream_read_len
*
* 读取指定长度的数据。
*
* @param {tk_iostream_t*} stream iostream对象。
* @param {void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
* @param {uint32_t} timeout_ms timeout.
*
* @return {int32_t} 返回负数表示读取失败，否则返回实际读取数据的长度。
*
*/
int32_t tk_iostream_read_len(tk_iostream_t* stream, void* buff, uint32_t max_size,
uint32_t timeout_ms);
/**
* @method tk_iostream_write
*
* 写入数据。
*
* @param {tk_iostream_t*} stream iostream对象。
* @param {const void*} buff 返回数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
*
* @return {int32_t} 返回负数表示写入失败，否则返回实际写入数据的长度。
*
*/
int32_t tk_iostream_write(tk_iostream_t* stream, const void* buff, uint32_t max_size);
/**
* @method tk_iostream_write_len
*
* 写入指定长度的数据。
*
* @param {tk_iostream_t*} stream iostream对象。
* @param {const void*} buff 数据的缓冲区。
* @param {uint32_t} max_size 缓冲区的大小。
* @param {uint32_t} timeout_ms timeout.
*
* @return {int32_t} 返回负数表示写入失败，否则返回实际写入数据的长度。
*
*/
int32_t tk_iostream_write_len(tk_iostream_t* stream, const void* buff, uint32_t max_size,
uint32_t timeout_ms);
/**
* @method tk_iostream_unref
*
* 引用计数减1。引用计数为0时，销毁对象。
* @param {tk_iostream_t*} stream iostream对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_iostream_unref(tk_iostream_t* stream);
#define TK_IOSTREAM(obj) ((tk_iostream_t*)(obj))
END_C_DECLS
#endif /*TK_TK_IOSTREAM_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/wstr.h
|
/**
* File: wstr.h
* Author: AWTK Develop Team
* Brief: width char
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-28 Li XianJing <[email protected]> adapt from uclib
*
*/
#ifndef WSTR_H
#define WSTR_H
#include "tkc/value.h"
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class wstr_t
* 可变长度的宽字符字符串。
*
* 示例：
*
* ```c
* wstr_t s;
* wstr_init(&s, 0);
*
* wstr_append(&s, L"abc");
* wstr_append(&s, L"123");
*
* wstr_reset(&s);
* ```
* > 先调wstr\_init进行初始化，最后调用wstr\_reset释放内存。
*
*/
typedef struct _wstr_t {
/**
* @property {uint32_t} size
* @annotation ["readable"]
* 长度。
*/
uint32_t size;
/**
* @property {uint32_t} capacity
* @annotation ["readable"]
* 容量。
*/
uint32_t capacity;
/**
* @property {wchar_t*} str
* @annotation ["readable"]
* 字符串。
*/
wchar_t* str;
/*private*/
bool_t extendable;
} wstr_t;
/**
* @method wstr_create
* 创建str对象。
* 备注：最后调用wstr\_destroy释放内存
* @annotation ["constructor"]
* @param {uint32_t} capacity 初始容量。
*
* @return {wstr_t*} str对象。
*/
wstr_t* wstr_create(uint32_t capacity);
/**
* @method wstr_destroy
* 销毁str对象。
* @param {wstr_t*} str str对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_destroy(wstr_t* str);
/**
* @method wstr_init
* 初始化字符串对象。
* 备注：最后调用wstr\_reset释放内存
* @annotation ["constructor"]
* @param {wstr_t*} str str对象。
* @param {uint32_t} capacity 初始容量。
*
* @return {wstr_t*} str对象本身。
*/
wstr_t* wstr_init(wstr_t* str, uint32_t capacity);
/**
* @method wstr_extend
* 扩展字符串到指定的容量。
* @param {wstr_t*} str wstr对象。
* @param {uint32_t} capacity 新的容量。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_extend(wstr_t* str, uint32_t capacity);
/**
* @method wstr_shrink
* 如果字符串长度大于指定长度，收缩字符串到指定的长度。
* @param {wstr_t*} str wstr对象。
* @param {uint32_t} size 新的长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_shrink(wstr_t* str, uint32_t size);
/**
* @method wstr_attach
* 通过附加到一个buff来初始化str。
* >可以避免str动态分配内存，同时也不会自动扩展内存，使用完成后无需调用str_reset。
*
*```c
* wstr_t s;
* wchar_t buff[32];
* wstr_attach(&s, buff, ARRAY_SIZE(buff));
* wstr_set(&s, L"abc");
* wstr_append(&s, L"123");
*```
*
* @annotation ["constructor"]
* @param {wstr_t*} str str对象。
* @param {wchar_t*} buff 缓冲区。
* @param {uint32_t} capacity 初始容量。
*
* @return {wstr_t*} str对象本身。
*/
wstr_t* wstr_attach(wstr_t* str, wchar_t* buff, uint32_t capacity);
/**
* @method wstr_set
* 设置字符串。
* @param {wstr_t*} str str对象。
* @param {const wchar_t*} text 要设置的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_set(wstr_t* str, const wchar_t* text);
/**
* @method wstr_set_with_len
* 设置字符串。
* @param {wstr_t*} str str对象。
* @param {const wchar_t*} text 要设置的字符串。
* @param {uint32_t} len 字符串长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_set_with_len(wstr_t* str, const wchar_t* text, uint32_t len);
/**
* @method wstr_clear
* 清除字符串内容。
* @param {wstr_t*} str str对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_clear(wstr_t* str);
/**
* @method wstr_set_utf8
* 设置UTF8字符串。
* @param {wstr_t*} str str对象。
* @param {const char*} text 要设置的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_set_utf8(wstr_t* str, const char* text);
/**
* @method wstr_set_utf8_with_len
* 设置UTF8字符串。
* @param {wstr_t*} str str对象。
* @param {const char*} text 要设置的字符串。
* @param {uint32_t} len 长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_set_utf8_with_len(wstr_t* str, const char* text, uint32_t len);
/**
* @method wstr_get_utf8
* 获取UTF8字符串。
* @param {wstr_t*} str str对象。
* @param {char*} text 返回的字符串。
* @param {uint32_t} size text最大长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_get_utf8(wstr_t* str, char* text, uint32_t size);
/**
* @method wstr_remove
* 删除指定范围的字符。
* @param {wstr_t*} str str对象。
* @param {uint32_t} offset 指定的位置。
* @param {uint32_t} nr 要删除的字符数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_remove(wstr_t* str, uint32_t offset, uint32_t nr);
/**
* @method wstr_insert
* 在指定位置插入字符串。
* @param {wstr_t*} str str对象。
* @param {uint32_t} offset 指定的位置。
* @param {const wchar_t*} text 待插入的文本。
* @param {uint32_t} nr 要插入的字符数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_insert(wstr_t* str, uint32_t offset, const wchar_t* text, uint32_t nr);
/**
* @method wstr_append
* 追加字符串。
* @param {wstr_t*} str str对象。
* @param {const wchar_t*} text 要追加的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_append(wstr_t* str, const wchar_t* text);
/**
* @method wstr_append_utf8
* 追加UTF8字符串。
* @param {wstr_t*} str str对象。
* @param {const char*} text 要设置的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_append_utf8(wstr_t* str, const char* text);
/**
* @method wstr_append_more
* 追加多个字符串。以NULL结束。
*
* 示例：
*
* ```c
* wstr_t s;
* wstr_init(&s, 0);
*
* wstr_append_more(&s, L"abc", L"123", NULL);
* log_debug("%s\n", s.str);
*
* wstr_reset(&s);
* ```
* @param {wstr_t*} str str对象。
* @param {const wchar_t*} text 要追加的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_append_more(wstr_t* str, const wchar_t* text, ...);
/**
* @method wstr_append_with_len
* 追加字符串。
* @param {wstr_t*} str str对象。
* @param {const wchar_t*} text 要追加的字符串。
* @param {uint32_t} len 字符串长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_append_with_len(wstr_t* str, const wchar_t* text, uint32_t len);
/**
* @method wstr_push
* 追加一个字符。
* @param {wstr_t*} str str对象。
* @param {const wchar_t} c 字符。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_push(wstr_t* str, const wchar_t c);
/**
* @method wstr_pop
* 删除尾部字符。
* @param {wstr_t*} str str对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_pop(wstr_t* str);
/**
* @method wstr_push_int
* 追加一个整数。
* @param {wstr_t*} str str对象。
* @param {const char*} format 格式(用于snprintf格式化数值)
* @param {int32_t} value 数值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_push_int(wstr_t* str, const char* format, int32_t value);
/**
* @method wstr_eq
* 判断两个字符串是否相等。
* @param {wstr_t*} str str对象。
* @param {const wchar_t*} text 待比较的字符串。
*
* @return {bool_t} 返回是否相等。
*/
bool_t wstr_eq(wstr_t* str, const wchar_t* text);
/**
* @method wstr_equal
* 判断两个字符是否相同。
* @param {wstr_t*} str str对象。
* @param {wstr_t*} other str对象。
*
* @return {bool_t} 返回TRUE表示相同，否则表示不同。
*/
bool_t wstr_equal(wstr_t* str, wstr_t* other);
/**
* @method wstr_from_int
* 用整数初始化字符串。
* @param {wstr_t*} str str对象。
* @param {int32_t} v 整数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_from_int(wstr_t* str, int32_t v);
/**
* @method wstr_from_int64
* 用整数初始化字符串。
* @param {wstr_t*} str str对象。
* @param {int64_t} v 整数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_from_int64(wstr_t* str, int64_t v);
/**
* @method wstr_append_int
* 追加整数到字符串。
* @param {wstr_t*} str str对象。
* @param {int32_t} v 整数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_append_int(wstr_t* str, int32_t v);
/**
* @method wstr_from_float
* 用浮点数初始化字符串。
* @param {wstr_t*} str str对象。
* @param {double} v 浮点数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_from_float(wstr_t* str, double v);
/**
* @method wstr_from_value
* 用value初始化字符串。
* @param {wstr_t*} str str对象。
* @param {const value_t*} v value。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_from_value(wstr_t* str, const value_t* v);
/**
* @method wstr_to_int
* 将字符串转成整数。
* @param {wstr_t*} str str对象。
* @param {int32_t*} v 用于返回整数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_to_int(wstr_t* str, int32_t* v);
/**
* @method wstr_to_int64
* 将字符串转成整数。
* @param {wstr_t*} str str对象。
* @param {int64_t*} v 用于返回整数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_to_int64(wstr_t* str, int64_t* v);
/**
* @method wstr_to_float
* 将字符串转成浮点数。
* @param {wstr_t*} str str对象。
* @param {double*} v 用于返回浮点数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_to_float(wstr_t* str, double* v);
/**
* @method wstr_add_float
* 将字符串转成浮点数，加上delta，再转换回来。
* @param {wstr_t*} str str对象。
* @param {double} delta 要加上的值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_add_float(wstr_t* str, double delta);
/**
* @method wstr_trim_float_zero
* 去掉浮点数小数点尾部的零。
* @param {wstr_t*} str str对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_trim_float_zero(wstr_t* str);
/**
* @method wstr_normalize_newline
* 规范化换行符。
* @param {wstr_t*} str str对象。
* @param {wchar_t} newline 换行符。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_normalize_newline(wstr_t* str, wchar_t newline);
/**
* @method wstr_count_char
* 统计指定字符的个数。
* @param {wstr_t*} str str对象。
* @param {wchar_t} c 字符。
*
* @return {uint32_t} 返回指定字符的个数。
*/
uint32_t wstr_count_char(wstr_t* str, wchar_t c);
/**
* @method wstr_reset
* 重置字符串为空。
* @param {wstr_t*} str str对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t wstr_reset(wstr_t* str);
/**
* @method wcs_chr
* 查找字符位置
* @annotation ["global"]
* @param {const wchar_t*} s wchar_t*。
* @param {wchar_t} c wchar_t。
*
* @return {const wchar_t*} 返回找到c的地址。
*/
const wchar_t* wcs_chr(const wchar_t* s, wchar_t c);
/**
* @method wcs_cpy
* 复制字符串
* @annotation ["global"]
* @param {wchar_t*} s1 目标串。
* @param {const wchar_t*} s2 源串。
*
* @return {wchar_t*} 复制后的串地址。
*/
wchar_t* wcs_cpy(wchar_t* s1, const wchar_t* s2);
/**
* @method wcs_ncpy
* 按照长度来复制字符串
* @annotation ["global"]
* @param {wchar_t*} s1 目标串。
* @param {const wchar_t*} s2 源串。
* @param {uint32_t} n 拷贝长度。
*
* @return {wchar_t*} 复制后的串地址。
*/
wchar_t* wcs_ncpy(wchar_t* s1, const wchar_t* s2, uint32_t n);
/**
* @method wcs_cmp
* 比较字符串
* @annotation ["global"]
* @param {const wchar_t*} s1 目标串。
* @param {const wchar_t*} s2 源串。
*
* @return {int} 小于0表示s1<s2,等于0表示s1==s2,大于0表示s1>s2。
*/
int wcs_cmp(const wchar_t* s1, const wchar_t* s2);
/**
* @method wcs_case_cmp
* 字符串比较函数（不区分大小写）
* @annotation ["global"]
* @param {const wchar_t*} s1 目标串。
* @param {const wchar_t*} s2 源串。
*
* @return {int} 小于0表示s1<s2,等于0表示s1==s2,大于0表示s1>s2。
*/
int wcs_case_cmp(const wchar_t* s1, const wchar_t* s2);
/**
* @method wcs_len
* 获取字符串长度。
* @annotation ["global"]
* @param {const wchar_t*} s 串地址。
*
* @return {size_t} 返回串长度'\0'结尾。
*/
size_t wcs_len(const wchar_t* s);
/**
* @method wcs_dup
* 获取一个新的内存保存s串。
* @annotation ["global"]
* @param {const wchar_t*} s 源字符串。
*
* @return {wchar_t*} 返回新的字符串地址。
*/
wchar_t* wcs_dup(const wchar_t* s);
#ifdef WITH_WCSXXX
#ifndef WITH_WASM
wchar_t* wcsdup(const wchar_t* s);
#endif /*WITH_WASM*/
#endif /*WITH_WCSXXX*/
#define WSTR_DESTROY(str) \
if (str != NULL) { \
wstr_destroy(str); \
str = NULL; \
}
END_C_DECLS
#endif /*WSTR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/tokenizer.h
|
/**
* File: tokenizer.h
* Author: AWTK Develop Team
* Brief: tokenizer
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is ditokenizeributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-17 Li XianJing <[email protected]> adapt from uclib
*
*/
#ifndef TK_TOKENIZER_H
#define TK_TOKENIZER_H
#include "tkc/str.h"
BEGIN_C_DECLS
/**
* @class tokenizer_t
* 从字符串中解析出一个一个的token。
*
* ```c
* tokenizer_t tokenizer;
* tokenizer_t* t = tokenizer_init(&tokenizer, "20,111.2,22.3,333.3,44,555.5", 0xffffff, ",");
*
* while(tokenizer_has_more(t)) {
* double v = tokenizer_next_float(t, 0);
* log_debug("%lf\n", v);
* }
*
* tokenizer_deinit(t);
* ```
*/
typedef struct _tokenizer_t {
/**
* @property {const char*} str
* @annotation ["readable"]
* 字符串。
*/
const char* str;
/**
* @property {uint32_t} size
* @annotation ["readable"]
* 字符串的长度。
*/
uint32_t size;
/**
* @property {uint32_t} cursor
* @annotation ["readable"]
* 当前位置。
*/
uint32_t cursor;
/**
* @property {const char*} separtor
* @annotation ["readable"]
* 分隔字符串。
*/
const char* separtor;
/**
* @property {const char*} single_char_token
* @annotation ["readable"]
* 单字符的token。
*/
const char* single_char_token;
str_t token;
} tokenizer_t;
/**
* @method tokenizer_init
* 初始化tokenizer对象。
* @annotation ["constructor"]
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {const char*} str 要解析的字符串。
* @param {uint32_t} size 字符串长度。
* @param {const char*} separtor 分隔字符。
*
* @return {tokenizer_t*} tokenizer对象本身。
*/
tokenizer_t* tokenizer_init(tokenizer_t* tokenizer, const char* str, uint32_t size,
const char* separtor);
/**
* @method tokenizer_init_ex
* 初始化tokenizer对象。
* @annotation ["constructor"]
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {const char*} str 要解析的字符串。
* @param {uint32_t} size 字符串长度。
* @param {const char*} separtor 分隔字符。
* @param {const char*} single_char_token 单字符token。
*
* @return {tokenizer_t*} tokenizer对象本身。
*/
tokenizer_t* tokenizer_init_ex(tokenizer_t* tokenizer, const char* str, uint32_t size,
const char* separtor, const char* single_char_token);
/**
* @method tokenizer_has_more
* 是否还有下一个token。
* @param {tokenizer_t*} tokenizer tokenizer对象。
*
* @return {bool_t} 还有下一个token返回TRUE，否则返回FALSE。
*/
bool_t tokenizer_has_more(tokenizer_t* tokenizer);
/**
* @method tokenizer_next
* 获取下一个token。
* @param {tokenizer_t*} tokenizer tokenizer对象。
*
* @return {const char*} 成功返回token，失败返回NULL。
*/
const char* tokenizer_next(tokenizer_t* tokenizer);
/**
* @method tokenizer_next_str
* 获取下一个字符串(允许使用英文单引号和双引号界定字符串)。
* @param {tokenizer_t*} tokenizer tokenizer对象。
*
* @return {const char*} 成功返回字符串，失败返回NULL。
*/
const char* tokenizer_next_str(tokenizer_t* tokenizer);
/**
* @method tokenizer_next_until
* 获取下一个token，该token直到遇到指定的char。
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {const char*} str 字符集。
*
* @return {const char*} 成功返回token，失败返回NULL。
*/
const char* tokenizer_next_until(tokenizer_t* tokenizer, const char* str);
/**
* @method tokenizer_next_expr_until
* 获取下一个expr，该expr直到遇到指定的char。
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {const char*} str 字符集。
*
* @return {const char*} 成功返回token，失败返回NULL。
*/
const char* tokenizer_next_expr_until(tokenizer_t* tokenizer, const char* str);
/**
* @method tokenizer_next_str_until
* 获取下一个str，该str直到遇到指定的char。
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {const char*} str 字符集。
*
* @return {const char*} 成功返回token，失败返回NULL。
*/
const char* tokenizer_next_str_until(tokenizer_t* tokenizer, const char* str);
/**
* @method tokenizer_next_int
* 获取下一个token，并转换成int。
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {int} defval 缺省值。
*
* @return {int} 成功返回token的int值，失败返回缺省值。
*/
int tokenizer_next_int(tokenizer_t* tokenizer, int defval);
/**
* @method tokenizer_next_int64
* 获取下一个token，并转换成int64_t。
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {int64_t} defval 缺省值。
*
* @return {int64_t} 成功返回token的int64_t值，失败返回缺省值。
*/
int64_t tokenizer_next_int64(tokenizer_t* tokenizer, int64_t defval);
/**
* @method tokenizer_next_float
* 获取下一个token，并转换成float。
* @param {tokenizer_t*} tokenizer tokenizer对象。
* @param {float} defval 缺省值。
*
* @return {float} 成功返回token的float值，失败返回缺省值。
*/
float tokenizer_next_float(tokenizer_t* tokenizer, float defval);
/**
* @method tokenizer_deinit
* 重置tokenizer。
* @param {tokenizer_t*} tokenizer tokenizer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tokenizer_deinit(tokenizer_t* tokenizer);
END_C_DECLS
#endif /*TK_TOKENIZER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/hash_table.h
|
/**
* File: hash_table.h
* Author: AWTK Develop Team
* Brief: hash table
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-11-15 Li XianJing <[email protected]> created
*
*/
#ifndef TK_HASH_TABLE_H
#define TK_HASH_TABLE_H
#include "tkc/darray.h"
BEGIN_C_DECLS
/**
* @class hash_table_t
* 哈希表。
*
* 用hash_table\_init初始化时，用hash_table\_deinit释放。如：
*
* ```c
* hash_table_t hash_table;
* hash_table_init(&hash_table, 10, destroy, compare, hash);
* ...
* hash_table_deinit(&hash_table);
* ```
*
* 用hash_table\_create创建时，用hash_table\_destroy销毁。如：
*
* ```c
* hash_table_t* hash_table = hash_table_create(10, destroy, compare, hash);
* ...
* hash_table_destroy(hash_table);
* ```
*
* 示例
*
*```c
* typedef struct _motor_t
* {
* int id;
* int position;
* int velocity;
* int acceleration;
* } motor_t;
*
* motor_t *motor_create(int id)
* {
* motor_t *motor = new motor_t;
* motor->id = id;
* motor->position = 0;
* motor->velocity = 0;
* motor->acceleration = 0;
* return motor;
* }
*
* ret_t motor_destroy(motor_t *motor)
* {
* delete motor;
* return RET_OK;
* }
*
* int motor_compare(const void *a, const void *b)
* {
* motor_t *motor_a = (motor_t *)a;
* motor_t *motor_b = (motor_t *)b;
*
* return motor_a->id - motor_b->id;
* }
*
* ret_t visist_motor(void *ctx, const void *data)
* {
* motor_t *motor = (motor_t *)data;
* log_debug("motor id: %d\n", motor->id);
* return RET_OK;
* }
*
* uint32_t motor_hash(const void *data)
* {
* motor_t *motor = (motor_t *)data;
* return motor->id;
* }
*
* void demo(void)
* {
* hash_table_t motors;
* motor_t *motor = NULL;
*
* // 初始化哈希表
* hash_table_init(&motors, 10, (tk_destroy_t)motor_destroy, (tk_compare_t)motor_compare, motor_hash);
*
* motor = motor_create(1);
* // 将motor添加到哈希表
* hash_table_add(&motors, motor, TRUE);
* ENSURE(hash_table_find(&motors, NULL, motor) == motor);
*
* motor = motor_create(2);
* // 将motor添加到哈希表
* hash_table_add(&motors, motor, TRUE);
* ENSURE(hash_table_find(&motors, NULL, motor) == motor);
*
* // 遍历哈希表
* log_debug("motors size: %d\n", hash_table_size(&motors));
* hash_table_foreach(&motors, visist_motor, NULL);
*
* // 释放哈希表
* hash_table_deinit(&motors);
* }
*```
*
*/
typedef struct _hash_table_t {
/**
* @property {darray_t} buckets
* @annotation ["readable"]
* buckets。
*/
darray_t buckets;
/**
* @property {tk_destroy_t} destroy
* @annotation ["readable"]
* 元素销毁函数。
*/
tk_destroy_t destroy;
/**
* @property {tk_compare_t} compare
* @annotation ["readable"]
* 元素比较函数。
*/
tk_compare_t compare;
/**
* @property {tk_hash_t} hash
* @annotation ["readable"]
* 元素哈希函数。
*/
tk_hash_t hash;
} hash_table_t;
/**
* @method hash_table_create
* @annotation ["constructor"]
* 创建hash_table对象。
*
* @param {uint32_t} capacity 哈希表桶数。
* @param {tk_destroy_t} destroy 元素销毁函数。
* @param {tk_compare_t} compare 元素比较函数。
* @param {tk_hash_t} hash 元素哈希函数。
*
* @return {hash_table_t*} 哈希表对象。
*/
hash_table_t* hash_table_create(uint32_t capacity, tk_destroy_t destroy, tk_compare_t compare,
tk_hash_t hash);
/**
* @method hash_table_init
* 初始化hash_table对象。
*
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {uint32_t} capacity 哈希表桶数。
* @param {tk_destroy_t} destroy 元素销毁函数。
* @param {tk_compare_t} compare 元素比较函数。
* @param {tk_hash_t} hash 元素哈希函数。
*
* @return {hash_table_t*} 哈希表对象。
*/
hash_table_t* hash_table_init(hash_table_t* hash_table, uint32_t capacity, tk_destroy_t destroy,
tk_compare_t compare, tk_hash_t hash);
/**
* @method hash_table_find
* 查找第一个满足条件的元素。
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {tk_compare_t} cmp 比较函数，为NULL则使用内置的比较函数。
* @param {void*} ctx 比较函数的上下文。
*
* @return {void*} 如果找到，返回满足条件的对象，否则返回NULL。
*/
void* hash_table_find(hash_table_t* hash_table, tk_compare_t cmp, void* ctx);
/**
* @method hash_table_add
* 加入一个元素。
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {void*} data 数据。
* @param {bool_t} replace_if_exist 如果存在是否替换。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_add(hash_table_t* hash_table, void* data, bool_t replace_if_exist);
/**
* @method hash_table_remove
* 删除第一个满足条件的元素。
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {tk_compare_t} cmp 比较函数，为NULL则使用内置的比较函数。
* @param {void*} ctx 比较函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_remove(hash_table_t* hash_table, tk_compare_t cmp, void* ctx);
/**
* @method hash_table_remove_all
* 删除全部满足条件的元素。
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {tk_compare_t} cmp 比较函数，为NULL则使用内置的比较函数。
* @param {void*} ctx 比较函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_remove_all(hash_table_t* hash_table, tk_compare_t cmp, void* ctx);
/**
* @method hash_table_size
* 返回全部元素个数。
* @param {hash_table_t*} hash_table 哈希表对象。
*
* @return {int32_t} 返回元素个数。
*/
int32_t hash_table_size(hash_table_t* hash_table);
/**
* @method hash_table_count
* 返回满足条件元素的个数。
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {tk_compare_t} cmp 比较函数，为NULL则使用内置的比较函数。
* @param {void*} ctx 比较函数的上下文。
*
* @return {int32_t} 返回元素个数。
*/
int32_t hash_table_count(hash_table_t* hash_table, tk_compare_t cmp, void* ctx);
/**
* @method hash_table_clear
* 清除全部元素。
* @param {hash_table_t*} hash_table 哈希表对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_clear(hash_table_t* hash_table);
/**
* @method hash_table_foreach
* 遍历元素。
* @param {hash_table_t*} hash_table 哈希表对象。
* @param {tk_visit_t} visit 遍历函数。
* @param {void*} ctx 遍历函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_foreach(hash_table_t* hash_table, tk_visit_t visit, void* ctx);
/**
* @method hash_table_deinit
* 清除全部元素，并释放elms。
* @param {hash_table_t*} hash_table 哈希表对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_deinit(hash_table_t* hash_table);
/**
* @method hash_table_destroy
* 销毁hash_table对象。
* @param {hash_table_t*} hash_table 哈希表对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t hash_table_destroy(hash_table_t* hash_table);
/**
* @method hash_table_hash_str
* 计算字符串hash值。
* @param {const void*} data 数据。
*
* @return {uint32_t} 返回hash值。
*/
uint32_t hash_table_hash_str(const void* data);
/**
* @method hash_table_hash_int
* 计算int的hash值。
* @param {const void*} data 数据。
*
* @return {uint32_t} 返回hash值。
*/
uint32_t hash_table_hash_int(const void* data);
END_C_DECLS
#endif /*TK_HASH_TABLE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/qaction.h
|
/**
* File: qaction.h
* Author: AWTK Develop Team
* Brief: qaction
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-06 Li XianJing <[email protected]> created
*
*/
#ifndef TK_QACTION_H
#define TK_QACTION_H
#include "tkc/event.h"
BEGIN_C_DECLS
struct _qaction_t;
typedef struct _qaction_t qaction_t;
typedef ret_t (*qaction_exec_t)(qaction_t* action);
typedef ret_t (*qaction_on_event_t)(qaction_t* action, event_t* event);
/**
* @class qaction_t
* 代表一个action，放在action queue中。
*/
struct _qaction_t {
/**
* @property {qaction_exec_t} exec
* @annotation ["readable"]
* 执行函数。
*/
qaction_exec_t exec;
/**
* @property {qaction_on_event_t} on_event
* @annotation ["readable"]
* 事件处理函数。如进度、错误和完成等。
*/
qaction_on_event_t on_event;
/**
* @property {uint32_t*} args
* @annotation ["readable"]
* exec的参数(视具体的action而不同)。
*/
uint32_t args[1];
};
/**
* @method qaction_create
* 创建action对象。
*
* @param {qaction_exec_t} exec 执行函数。
* @param {void*} args 参数。
* @param {uint32_t} args_size 参数长度。
*
* @return {qaction_t*} 返回action对象。
*/
qaction_t* qaction_create(qaction_exec_t exec, void* args, uint32_t args_size);
/**
* @method qaction_set_on_event
* 设置事件处理函数(回调函数在后台线程执行)。
*
*> exec执行完成后，会触发EVT\_DONE事件，一般在EVT\_DONE事件中调用qaction\_destroy函数销毁action。
*
* @param {qaction_t*} action action对象。
* @param {qaction_on_event_t} on_event 事件处理函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t qaction_set_on_event(qaction_t* action, qaction_on_event_t on_event);
/**
* @method qaction_exec
* 执行。
*
* @param {qaction_t*} action action对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t qaction_exec(qaction_t* action);
/**
* @method qaction_notify
* 事件通知。
*
* @param {qaction_t*} action action对象。
* @param {event_t*} event event对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t qaction_notify(qaction_t* action, event_t* event);
/**
* @method qaction_destroy
* 销毁。
*
* @param {qaction_t*} q qaction对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t qaction_destroy(qaction_t* q);
END_C_DECLS
#endif /*TK_QACTION_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/serial_helper.h
|
/**
* File: serial_helper.h
* Author: AWTK Develop Team
* Brief: serial helper functions
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-11 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SERIAL_HELPER_H
#define TK_SERIAL_HELPER_H
#include <errno.h>
#include <string.h>
#include "tkc/types_def.h"
BEGIN_C_DECLS
#ifdef WITH_WASM
typedef int64_t serial_handle_t;
typedef int64_t serial_dev_t;
#elif defined(WIN32)
#include "windows.h"
#include "tkc/mutex.h"
#include "tkc/cond_var.h"
#include "tkc/thread.h"
typedef HANDLE serial_dev_t;
typedef struct _serial_info_t {
serial_dev_t dev;
OVERLAPPED read_overlapped;
OVERLAPPED write_overlapped;
bool_t closed;
bool_t has_signal;
int client_fd;
int server_fd;
tk_cond_t* cond;
tk_mutex_t* mutex;
tk_thread_t* thread;
} serial_info_t;
typedef struct _serial_info_t* serial_handle_t;
#else
#if defined(LINUX) || defined(MACOS)
#include <unistd.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#endif /*LINUX || MACOS*/
typedef int serial_dev_t;
typedef struct _serial_info_t {
serial_dev_t dev;
uint8_t* old_options;
} serial_info_t;
typedef struct _serial_info_t* serial_handle_t;
#endif /*WIN32*/
/**
* @enum bytesize_t
* 串口字节位数。
*/
typedef enum {
/**
* @const fivebits
* 每字节5位。
*/
fivebits = 5,
/**
* @const sixbits
* 每字节6位。
*/
sixbits = 6,
/**
* @const sevenbits
* 每字节7位。
*/
sevenbits = 7,
/**
* @const eightbits
* 每字节8位。
*/
eightbits = 8
} bytesize_t;
/**
* @enum parity_t
* 串口奇偶校验。
*/
typedef enum {
/**
* @const parity_none
* 无。
*/
parity_none = 0,
/**
* @const parity_odd
* 奇校验。
*/
parity_odd = 1,
/**
* @const parity_even
* 偶校验。
*/
parity_even = 2,
/**
* @const parity_mark
* 校验位的电平保持为逻辑 "1"。
*/
parity_mark = 3,
/**
* @const parity_space
* 校验位的电平保持为逻辑 "0"。
*/
parity_space = 4
} parity_t;
/**
* @enum stopbits_t
* 串口停止位。
*/
typedef enum {
/**
* @const stopbits_one
* 1位。
*/
stopbits_one = 1,
/**
* @const stopbits_two
* 2位。
*/
stopbits_two = 2,
/**
* @const stopbits_one_point_five
* 1.5位。
*/
stopbits_one_point_five
} stopbits_t;
/**
* @enum flowcontrol_t
* 串口流控。
*/
typedef enum {
/**
* @const flowcontrol_none
* 无。
*/
flowcontrol_none = 0,
/**
* @const flowcontrol_software
* 软件。
*/
flowcontrol_software,
/**
* @const flowcontrol_hardware
* 硬件。
*/
flowcontrol_hardware
} flowcontrol_t;
/**
* @class serial_t
* @annotation ["fake"]
*/
/**
* @method serial_open
* 打开串口
* > Windows下，需要在应用程序初始化时，调用 tk_socket_init。
* @annotation ["static"]
* @param {const char*} port 串口号。
*
* @return {serial_handle_t} 失败返回NULL。
*/
serial_handle_t serial_open(const char* port);
/**
* @method serial_read
* 串口读数据
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
* @param {uint8_t*} buff 数据缓冲区。
* @param {uint32_t} max_size 数据长度。
*
* @return {int32_t} 返回实际读取的字节数。
*/
int32_t serial_read(serial_handle_t handle, uint8_t* buff, uint32_t max_size);
/**
* @method serial_write
* 串口写数据
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
* @param {const uint8_t*} buff 数据缓冲区。
* @param {uint32_t} max_size 数据长度。
*
* @return {int32_t} 返回实际写入的字节数。
*/
int32_t serial_write(serial_handle_t handle, const uint8_t* buff, uint32_t max_size);
/**
* @method serial_close
* 关闭串口
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_close(serial_handle_t handle);
/**
* @method serial_config
* 配置串口
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
* @param {uint32_t} baudrate 波特率。
* @param {bytesize_t} bytesize 数据位。
* @param {stopbits_t} stopbits 停止位
* @param {flowcontrol_t} flowcontrol 流控。
* @param {parity_t} parity 校验位。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_config(serial_handle_t handle, uint32_t baudrate, bytesize_t bytesize,
stopbits_t stopbits, flowcontrol_t flowcontrol, parity_t parity);
/**
* @method serial_handle_get_fd
* 获取文件描述符。
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
*
* @return {int} 返回文件描述符。
*/
int serial_handle_get_fd(serial_handle_t handle);
/**
* @method serial_handle_get_dev
* 获取设备句柄。
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
*
* @return {serial_dev_t} 返回设备句柄。
*/
serial_dev_t serial_handle_get_dev(serial_handle_t handle);
/**
* @method serial_iflush
* 刷新input缓冲区。
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_iflush(serial_handle_t handle);
/**
* @method serial_oflush
* 刷新output缓冲区。
* @annotation ["static"]
* @param {serial_handle_t} handle 串口句柄。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_oflush(serial_handle_t handle);
/**
* @method serial_wait_for_data
* @annotation ["static"]
* 等待数据。
*
* @param {serial_handle_t} handle 串口句柄。
* @param {uint32_t} timeout_ms 等待时间(毫秒)。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t serial_wait_for_data(serial_handle_t handle, uint32_t timeout_ms);
/**
* @method serial_stopbits_from_str
* 字符串转stopbits
* @annotation ["static"]
* @param {const char*} str 字符串。
*
* @return {stopbits_t} 返回stopbits。
*/
stopbits_t serial_stopbits_from_str(const char* str);
/**
* @method serial_flowcontrol_from_str
* 字符串转flowcontrol
* @annotation ["static"]
* @param {const char*} str 字符串。
*
* @return {flowcontrol_t} 返回flowcontrol。
*/
flowcontrol_t serial_flowcontrol_from_str(const char* str);
/**
* @method serial_parity_from_str
* 字符串转parity
* @annotation ["static"]
* @param {const char*} str 字符串。
*
* @return {parity_t} 返回parity。
*/
parity_t serial_parity_from_str(const char* str);
/**
* @method serial_bytesize_from_str
* 字符串转bytesize
* @annotation ["static"]
* @param {const char*} str 字符串。
*
* @return {bytesize_t} 返回bytesize。
*/
bytesize_t serial_bytesize_from_str(const char* str);
/*不再使用 begin{*/
typedef struct {
uint32_t rd_timeout; /* 读超时时间(毫秒) */
uint32_t rd_interval_timeout; /* 码间超时(毫秒) */
} serial_timeout_t;
ret_t serial_timeout_set(serial_handle_t handle, serial_timeout_t* timeout);
ret_t serial_timeout_get(serial_handle_t handle, serial_timeout_t* timeout);
/*}不再使用 end*/
END_C_DECLS
#endif /*TK_SERIAL_HELPER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/istream.c
|
/**
* File: tk_istream.h
* Author: AWTK Develop Team
* Brief: input stream interface
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-27 Li XianJing <[email protected]> created
*
*/
#include "tkc/platform.h"
#include "tkc/time_now.h"
#include "tkc/istream.h"
int32_t tk_istream_read(tk_istream_t* stream, void* buff, uint32_t max_size) {
return_value_if_fail(stream != NULL && stream->read != NULL, -1);
return_value_if_fail(buff != NULL, 0);
return stream->read(stream, (uint8_t*)buff, max_size);
}
ret_t tk_istream_seek(tk_istream_t* stream, uint32_t offset) {
return_value_if_fail(stream != NULL, RET_BAD_PARAMS);
return_value_if_fail(stream->seek != NULL, RET_NOT_IMPL);
return stream->seek(stream, offset);
}
int32_t tk_istream_tell(tk_istream_t* stream) {
return_value_if_fail(stream != NULL, -1);
return_value_if_fail(stream->tell != NULL, -1);
return stream->tell(stream);
}
bool_t tk_istream_eos(tk_istream_t* stream) {
return_value_if_fail(stream != NULL, TRUE);
if (stream->eos != NULL) {
return stream->eos(stream);
} else {
return FALSE;
}
}
ret_t tk_istream_wait_for_data(tk_istream_t* stream, uint32_t timeout_ms) {
return_value_if_fail(stream != NULL, RET_BAD_PARAMS);
return_value_if_fail(stream->wait_for_data != NULL, RET_NOT_IMPL);
return stream->wait_for_data(stream, timeout_ms);
}
ret_t tk_istream_flush(tk_istream_t* stream) {
return_value_if_fail(stream != NULL, RET_BAD_PARAMS);
if (stream->flush != NULL) {
return stream->flush(stream);
}
return RET_OK;
}
int32_t tk_istream_read_len(tk_istream_t* stream, void* buff, uint32_t max_size,
uint32_t timeout_ms) {
uint32_t now = 0;
uint32_t end = 0;
int32_t offset = 0;
ret_t ret = RET_OK;
int32_t read_bytes = 0;
int32_t remain_bytes = max_size;
uint8_t* p = (uint8_t*)buff;
return_value_if_fail(stream != NULL && stream->read != NULL, -1);
return_value_if_fail(buff != NULL, 0);
now = time_now_ms();
end = now + timeout_ms;
do {
errno = 0;
ret = tk_istream_wait_for_data(stream, 20);
if (ret == RET_TIMEOUT) {
now = time_now_ms();
if (now > end) {
break;
} else {
continue;
}
} else if (ret != RET_OK) {
break;
}
read_bytes = tk_istream_read(stream, p + offset, remain_bytes);
if (read_bytes <= 0) {
if (!tk_object_get_prop_bool(TK_OBJECT(stream), TK_STREAM_PROP_IS_OK, TRUE)) {
log_debug("stream is broken\n");
break;
} else {
now = time_now_ms();
if (now > end) {
log_debug("timeout\n");
break;
} else {
log_debug("not get data\n");
continue;
}
}
}
offset += read_bytes;
remain_bytes -= read_bytes;
if (remain_bytes == 0) {
break;
}
if (tk_object_get_prop_bool(TK_OBJECT(stream), TK_STREAM_PROP_IS_EOS, FALSE)) {
log_debug("stream is end\n");
break;
}
now = time_now_ms();
if (now > end) {
break;
}
log_debug("read: %d/%u\n", offset, max_size);
} while (remain_bytes > 0);
return offset;
}
int32_t tk_istream_read_line(tk_istream_t* stream, void* buff, uint32_t max_size,
uint32_t timeout_ms) {
uint64_t start = 0;
uint64_t end = 0;
int32_t offset = 0;
int32_t read_bytes = 0;
uint8_t* p = (uint8_t*)buff;
int32_t remain_bytes = max_size - 1;
ret_t ret = RET_OK;
return_value_if_fail(stream != NULL && stream->read != NULL, -1);
return_value_if_fail(buff != NULL && max_size > 1, 0);
start = time_now_ms();
end = start + timeout_ms;
do {
ret = tk_istream_wait_for_data(stream, 20);
if (ret == RET_TIMEOUT) {
if (time_now_ms() > end) {
break;
} else {
continue;
}
} else if (ret != RET_OK) {
break;
}
read_bytes = tk_istream_read(stream, p + offset, 1);
if (read_bytes < 0) {
if (!tk_object_get_prop_bool(TK_OBJECT(stream), TK_STREAM_PROP_IS_OK, TRUE)) {
log_debug("stream is broken\n");
}
break;
} else if (read_bytes == 0 && tk_istream_eos(stream)) {
break;
}
offset += read_bytes;
remain_bytes -= read_bytes;
if (time_now_ms() > end) {
break;
}
if (offset > 0 && p[offset - 1] == '\n') {
break;
}
} while (remain_bytes > 0);
p[offset] = '\0';
return offset;
}
ret_t tk_istream_read_line_str(tk_istream_t* stream, str_t* str) {
char line[64];
int32_t size = 0;
bool_t got_end_line = FALSE;
return_value_if_fail(stream != NULL && str != NULL, RET_BAD_PARAMS);
return_value_if_fail(stream->tell != NULL && stream->seek != NULL && stream->eos != NULL,
RET_BAD_PARAMS);
str_set(str, "");
if (tk_istream_eos(stream)) {
return RET_DONE;
}
while (!tk_istream_eos(stream) && got_end_line == FALSE) {
size = tk_istream_read(stream, line, sizeof(line) - 1);
if (size >= 0) {
int32_t i = 0;
for (i = 0; i < size; i++) {
if (line[i] == '\r' || line[i] == '\n') {
got_end_line = TRUE;
break;
}
}
ENSURE(str_append_with_len(str, line, i) == RET_OK);
/*not found end line*/
if (i == size) {
continue;
}
if (line[i] == '\r') {
i++;
if (line[i] == '\n') {
i++;
}
} else if (line[i] == '\n') {
i++;
}
if (i < size) {
int32_t pos = tk_istream_tell(stream);
pos = pos - (size - i);
ENSURE(tk_istream_seek(stream, pos) == RET_OK);
}
} else {
break;
}
}
return RET_OK;
}
ret_t tk_istream_read_uint8(tk_istream_t* stream, uint8_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_uint16(tk_istream_t* stream, uint16_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_uint32(tk_istream_t* stream, uint32_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_uint64(tk_istream_t* stream, uint64_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_int8(tk_istream_t* stream, int8_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_int16(tk_istream_t* stream, int16_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_int32(tk_istream_t* stream, int32_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_int64(tk_istream_t* stream, int64_t* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_float(tk_istream_t* stream, float* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_read_double(tk_istream_t* stream, double* value) {
int32_t ret = tk_istream_read_len(stream, value, sizeof(*value), TK_ISTREAM_DEFAULT_TIMEOUT);
return ret == sizeof(*value) ? RET_OK : RET_FAIL;
}
ret_t tk_istream_unref(tk_istream_t* stream) {
return tk_object_unref(TK_OBJECT(stream));
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_thread_pool.c
|
/**
* File: action_thread_pool.c
* Author: AWTK Develop Team
* Brief: action_thread_pool
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-08 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/action_thread_pool.h"
action_thread_pool_t* action_thread_pool_create(uint16_t max_thread_nr, uint16_t min_idle_nr) {
return action_thread_pool_create_ex(max_thread_nr, min_idle_nr, 0, TK_THREAD_PRIORITY_NORMAL);
}
action_thread_pool_t* action_thread_pool_create_ex(uint16_t max_thread_nr, uint16_t min_idle_nr,
uint32_t stack_size,
tk_thread_priority_t priority) {
action_thread_pool_t* thread_pool = NULL;
uint32_t size = sizeof(action_thread_pool_t) + sizeof(action_thread_t*) * max_thread_nr;
return_value_if_fail(max_thread_nr > 0 && min_idle_nr > 0, NULL);
thread_pool = (action_thread_pool_t*)TKMEM_ALLOC(size);
return_value_if_fail(thread_pool != NULL, NULL);
memset(thread_pool, 0x00, size);
thread_pool->priority = priority;
thread_pool->stack_size = stack_size;
thread_pool->min_idle_nr = min_idle_nr;
thread_pool->max_thread_nr = max_thread_nr;
thread_pool->mutex = tk_mutex_create();
goto_error_if_fail(thread_pool->mutex != NULL);
thread_pool->queue = waitable_action_queue_create(max_thread_nr * 5);
goto_error_if_fail(thread_pool->queue != NULL);
return thread_pool;
error:
if (thread_pool->mutex != NULL) {
tk_mutex_destroy(thread_pool->mutex);
}
if (thread_pool->queue != NULL) {
waitable_action_queue_destroy(thread_pool->queue);
}
TKMEM_FREE(thread_pool);
return NULL;
}
static uint32_t action_thread_pool_get_thread_nr(action_thread_pool_t* thread_pool) {
uint32_t i = 0;
uint32_t n = 0;
action_thread_t* thread = NULL;
return_value_if_fail(thread_pool != NULL, 0);
return_value_if_fail(tk_mutex_lock(thread_pool->mutex) == RET_OK, 0);
for (i = 0; i < thread_pool->max_thread_nr; i++) {
thread = thread_pool->threads[i];
if (thread != NULL) {
n++;
}
}
tk_mutex_unlock(thread_pool->mutex);
return n;
}
static ret_t action_thread_pool_on_thread_idle(action_thread_pool_t* thread_pool,
action_thread_t* thread) {
uint32_t i = 0;
uint32_t thread_nr = action_thread_pool_get_thread_nr(thread_pool);
return_value_if_fail(thread_pool != NULL && thread != NULL, RET_BAD_PARAMS);
if (thread_nr > thread_pool->min_idle_nr || thread->quit) {
for (i = 0; i < thread_pool->max_thread_nr; i++) {
if (thread == thread_pool->threads[i]) {
thread_pool->threads[i] = NULL;
break;
}
}
return RET_QUIT;
}
return RET_OK;
}
static ret_t action_thread_pool_create_thread(action_thread_pool_t* thread_pool) {
uint32_t i = 0;
return_value_if_fail(thread_pool != NULL, RET_BAD_PARAMS);
return_value_if_fail(tk_mutex_lock(thread_pool->mutex) == RET_OK, RET_BAD_PARAMS);
for (i = 0; i < thread_pool->max_thread_nr; i++) {
if (thread_pool->threads[i] == NULL) {
thread_pool->threads[i] = action_thread_create_with_queue_ex(
thread_pool->queue, NULL, thread_pool->stack_size, thread_pool->priority);
action_thread_set_on_idle(thread_pool->threads[i],
(action_thread_on_idle_t)action_thread_pool_on_thread_idle,
thread_pool);
break;
}
}
return tk_mutex_unlock(thread_pool->mutex);
}
static ret_t action_thread_pool_ensure_threads(action_thread_pool_t* thread_pool) {
uint32_t thread_nr = action_thread_pool_get_thread_nr(thread_pool);
return_value_if_fail(thread_pool != NULL, RET_BAD_PARAMS);
if (thread_nr < thread_pool->min_idle_nr) {
return action_thread_pool_create_thread(thread_pool);
}
return RET_OK;
}
ret_t action_thread_pool_exec(action_thread_pool_t* thread_pool, qaction_t* action) {
return_value_if_fail(thread_pool != NULL && action != NULL, RET_BAD_PARAMS);
return_value_if_fail(action_thread_pool_ensure_threads(thread_pool) == RET_OK, RET_FAIL);
if (thread_pool->queue->queue->full) {
action_thread_pool_create_thread(thread_pool);
}
return waitable_action_queue_send(thread_pool->queue, action, 1000);
}
ret_t action_thread_pool_destroy(action_thread_pool_t* thread_pool) {
uint32_t i = 0;
action_thread_t* thread = NULL;
return_value_if_fail(thread_pool != NULL, RET_BAD_PARAMS);
for (i = 0; i < thread_pool->max_thread_nr; i++) {
thread = thread_pool->threads[i];
if (thread != NULL) {
action_thread_destroy(thread);
thread_pool->threads[i] = NULL;
}
}
tk_mutex_destroy(thread_pool->mutex);
waitable_action_queue_destroy(thread_pool->queue);
memset(thread_pool, 0x00, sizeof(action_thread_pool_t));
TKMEM_FREE(thread_pool);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_lock.h
|
/**
* File: mem_allocator_lock.h
* Author: AWTK Develop Team
* Brief: mem_allocator_lock
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_LOCK_H
#define TK_MEM_ALLOCATOR_LOCK_H
#include "tkc/mutex.h"
#include "tkc/mem_allocator.h"
BEGIN_C_DECLS
/**
* @class mem_allocator_lock_t
* @parent mem_allocator_t
*
* 对现有的allocator进行包装，提供互斥功能。
*
*/
typedef struct _mem_allocator_lock_t {
mem_allocator_t allocator;
mem_allocator_t* impl;
tk_mutex_t* mutex;
} mem_allocator_lock_t;
#define MEM_ALLOCATOR_LOCK(allocator) ((mem_allocator_lock_t*)(allocator))
static inline void* mem_allocator_lock_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
void* addr = NULL;
tk_mutex_t* mutex = MEM_ALLOCATOR_LOCK(allocator)->mutex;
mem_allocator_t* impl = MEM_ALLOCATOR_LOCK(allocator)->impl;
if (tk_mutex_lock(mutex) == RET_OK) {
addr = mem_allocator_alloc(impl, size, func, line);
ENSURE(tk_mutex_unlock(mutex) == RET_OK);
}
return addr;
}
static inline void* mem_allocator_lock_realloc(mem_allocator_t* allocator, void* ptr, uint32_t size,
const char* func, uint32_t line) {
void* addr = NULL;
tk_mutex_t* mutex = MEM_ALLOCATOR_LOCK(allocator)->mutex;
mem_allocator_t* impl = MEM_ALLOCATOR_LOCK(allocator)->impl;
if (tk_mutex_lock(mutex) == RET_OK) {
addr = mem_allocator_realloc(impl, ptr, size, func, line);
ENSURE(tk_mutex_unlock(mutex) == RET_OK);
}
return addr;
}
static inline void mem_allocator_lock_free(mem_allocator_t* allocator, void* ptr) {
tk_mutex_t* mutex = MEM_ALLOCATOR_LOCK(allocator)->mutex;
mem_allocator_t* impl = MEM_ALLOCATOR_LOCK(allocator)->impl;
if (tk_mutex_lock(mutex) == RET_OK) {
mem_allocator_free(impl, ptr);
ENSURE(tk_mutex_unlock(mutex) == RET_OK);
}
}
static inline ret_t mem_allocator_lock_dump(mem_allocator_t* allocator) {
tk_mutex_t* mutex = MEM_ALLOCATOR_LOCK(allocator)->mutex;
mem_allocator_t* impl = MEM_ALLOCATOR_LOCK(allocator)->impl;
if (tk_mutex_lock(mutex) == RET_OK) {
mem_allocator_dump(impl);
ENSURE(tk_mutex_unlock(mutex) == RET_OK);
}
return RET_OK;
}
static inline ret_t mem_allocator_lock_destroy(mem_allocator_t* allocator) {
tk_mutex_t* mutex = MEM_ALLOCATOR_LOCK(allocator)->mutex;
mem_allocator_t* impl = MEM_ALLOCATOR_LOCK(allocator)->impl;
mem_allocator_destroy(impl);
tk_mutex_destroy(mutex);
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_lock_vtable = {
.alloc = mem_allocator_lock_alloc,
.realloc = mem_allocator_lock_realloc,
.free = mem_allocator_lock_free,
.dump = mem_allocator_lock_dump,
.destroy = mem_allocator_lock_destroy};
static inline mem_allocator_t* mem_allocator_lock_init(mem_allocator_lock_t* lock,
mem_allocator_t* impl) {
mem_allocator_t* allocator = MEM_ALLOCATOR(lock);
return_value_if_fail(impl != NULL && lock != NULL, NULL);
memset(lock, 0x00, sizeof(*lock));
allocator->vt = &s_mem_allocator_lock_vtable;
lock->mutex = tk_mutex_create();
lock->impl = impl;
return allocator;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_LOCK_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/platform.h
|
/**
* File: platform.h
* Author: AWTK Develop Team
* Brief: platform struct and utils functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#ifndef TK_PLATFORM_H
#define TK_PLATFORM_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class platform_t
* @annotation ["fake"]
* 平台接口，包括：获取时间、休眠等函数。
*/
/**
* @method get_time_ms64
* 获取当前时间(毫秒)。
*
* @return {uint64_t} 成功返回当前时间。
*/
uint64_t get_time_ms64(void);
/**
* @method get_time_us64
* 获取当前时间(微秒)。
*
* @return {uint64_t} 成功返回当前时间。
*/
uint64_t get_time_us64(void);
/**
* @method sleep_ms
*
* 睡眠指定时间。
*
* @param {uint32_t} ms 睡眠时间(毫秒)。
*
* @return {void} 无。
*/
void sleep_ms(uint32_t ms);
/**
* @method sleep_us
*
* 睡眠指定时间。
*
* @param {uint32_t} us 睡眠时间(微秒)。
*
* @return {void} 无。
*/
void sleep_us(uint32_t us);
/**
* @method platform_prepare
*
* 平台准备函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t platform_prepare(void);
END_C_DECLS
#endif /*TK_PLATFORM_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/int_str.h
|
/**
* File: int_str.h
* Author: AWTK Develop Team
* Brief: map between int and str
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-31 Li XianJing <[email protected]> created
*
*/
#ifndef TK_INT_STR_H
#define TK_INT_STR_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class int_str_t
* @annotation ["fake"]
* 数字-字符串类型。
*
* 负责把一个数字映射成一个字符串。
*
* 示例：
*
* ```c
* static const int_str_t color_values[] = {{1, "red"}, {2, "black"}, {3, "blue"}, {4, "white"}};
* const char* value = int_str_value(color_values, 3);
* int32_t name = int_str_name(color_values, "blue", 0);
* printf("value = %s \n", value);
* printf("name = %d \n", name);
* ```
*/
typedef struct _int_str_t {
int32_t name;
const char* value;
} int_str_t;
/**
* @method int_str_value
* 根据name获取对应的value。
*
* @param {const int_str_t*} items int_str_t数组。
* @param {int32_t} name name。
*
* @return {const char*} 返回value。
*/
const char* int_str_value(const int_str_t* items, int32_t name);
/**
* @method int_str_name
* 根据value获取对应的name。
*
* @param {const int_str_t*} items int_str_t数组。
* @param {const char*} value value。
* @param {int32_t} defval 如果没有找到对应的name，则返回的defval默认值。
*
* @return {int32_t} 返回name。
*/
int32_t int_str_name(const int_str_t* items, const char* value, int32_t defval);
END_C_DECLS
#endif /*TK_INT_STR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/cond.h
|
/**
* File: cond.h
* Author: AWTK Develop Team
* Brief: cond
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-05-11 Li XianJing <[email protected]> created
*
*/
#ifndef TK_COND_VAR_H
#define TK_COND_VAR_H
#include "tkc/mutex.h"
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class tk_cond_t
* 条件变量。
*/
struct _tk_cond_t;
typedef struct _tk_cond_t tk_cond_t;
/**
* @method tk_cond_create
* 创建cond。
*
* @return {tk_cond_t*} cond对象。
*/
tk_cond_t* tk_cond_create(void);
/**
* @method tk_cond_wait
* 等待。
* @param {tk_cond_t*} cond cond对象。
* @param {tk_mutex_t*} mutex mutex对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_wait(tk_cond_t* cond, tk_mutex_t* mutex);
/**
* @method tk_cond_wait_timeout
* 等待指定时间(毫秒)。
* @param {tk_cond_t*} cond cond对象。
* @param {tk_mutex_t*} mutex mutex对象。
* @param {uint32_t} timeout 最长等待时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_wait_timeout(tk_cond_t* cond, tk_mutex_t* mutex, uint32_t timeout);
/**
* @method tk_cond_signal
* 唤醒。
* @param {tk_cond_t*} cond cond对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_signal(tk_cond_t* cond);
/**
* @method tk_cond_destroy
* 销毁cond对象。
* @param {tk_cond_t*} cond cond对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_cond_destroy(tk_cond_t* cond);
END_C_DECLS
#endif /*TK_COND_VAR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/rom_fs.c
|
/**
* File: rom_file.c
* Author: AWTK Develop Team
* Brief: posix file api for rom data.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-06-23 Li XianJing <[email protected]> created
*
*/
#include "tkc/asset_info.h"
#ifndef SEEK_SET
#define SEEK_SET 0 /* set file offset to offset */
#endif
#ifndef SEEK_CUR
#define SEEK_CUR 1 /* set file offset to current plus offset */
#endif
#ifndef SEEK_END
#define SEEK_END 2 /* set file offset to EOF plus offset */
#endif
#include "tkc/mem.h"
#include "tkc/rom_fs.h"
rom_file_t* rom_fopen(const char* name, const char* mode) {
const asset_info_t* res = (const asset_info_t*)(name);
return_value_if_fail(res != NULL && mode != NULL, NULL);
return rom_fopen_buff(res->data, res->size);
}
rom_file_t* rom_fopen_buff(const uint8_t* data, uint32_t capacity) {
rom_file_t* f = NULL;
return_value_if_fail(data != NULL, NULL);
f = TKMEM_ZALLOC(rom_file_t);
return_value_if_fail(f != NULL, NULL);
f->cursor = 0;
f->data = data;
f->capacity = capacity;
return f;
}
size_t rom_fread(void* ptr, size_t size, size_t nitems, rom_file_t* f) {
size_t available = 0;
size_t nr = size * nitems;
return_value_if_fail(size > 0, 0);
return_value_if_fail(ptr != NULL && f != NULL, 0);
available = f->capacity - f->cursor;
nr = tk_min(nr, available);
memcpy(ptr, f->data + f->cursor, nr);
f->cursor += nr;
return nr / size;
}
size_t rom_fwrite(const void* ptr, size_t size, size_t nitems, rom_file_t* f) {
return_value_if_fail(ptr != NULL && f != NULL, 0);
(void)size;
(void)nitems;
return nitems;
}
long rom_ftell(rom_file_t* f) {
return_value_if_fail(f != NULL, -1);
return f->cursor;
}
int rom_feof(rom_file_t* f) {
return_value_if_fail(f != NULL, 1);
return f->cursor >= f->capacity;
}
int rom_ferror(rom_file_t* f) {
return 0;
}
int rom_fseek(rom_file_t* f, long offset, int whence) {
return_value_if_fail(f != NULL, 1);
switch (offset) {
case SEEK_SET: {
f->cursor = whence;
break;
}
case SEEK_END: {
f->cursor = f->capacity;
}
default: {
f->cursor += whence;
break;
}
}
return 0;
}
ret_t rom_fclose(rom_file_t* f) {
return_value_if_fail(f != NULL, RET_BAD_PARAMS);
TKMEM_FREE(f);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/func_desc.h
|
/**
* File: func_desc.h
* Author: AWTK Develop Team
* Brief: func_desc
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_FUNC_DESC_H
#define TK_FUNC_DESC_H
#include "tkc/value_desc.h"
BEGIN_C_DECLS
typedef ret_t (*func_exec_t)(void* obj, value_t* ret, tk_object_t* args);
/**
* @class func_desc_t
* 函数描述。
*/
typedef struct _func_desc_t {
/**
* @property {const char*} name
* @annotation ["readable"]
* 名称。
*/
const char* name;
/**
* @property {const char*} desc
* @annotation ["readable"]
* 描述。
*/
const char* desc;
/**
* @property {func_exec_t} exec
* @annotation ["readable"]
* 函数指针。
*/
func_exec_t exec;
/**
* @property {const arg_desc_t**} args
* @annotation ["readable"]
* 函数参数描述。
*/
const arg_desc_t** args;
/**
* @property {const value_desc_t*} return_value
* @annotation ["readable"]
* 函数返回值描述。
*/
const value_desc_t* return_value;
} func_desc_t;
END_C_DECLS
#endif /*TK_FUNC_DESC_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/rect.c
|
/**
* File: rect.c
* Author: AWTK Develop Team
* Brief: rect struct and utils functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-13 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/rect.h"
#define rectX_fix \
{ \
if (r->x < 0) { \
r->x = 0; \
} \
\
if (r->x > max_w) { \
r->x = max_w; \
r->w = 0; \
} \
\
if (r->y < 0) { \
r->y = 0; \
} \
\
if (r->y > max_h) { \
r->y = max_h; \
r->h = 0; \
} \
\
if (r->w < 0) { \
r->w = 0; \
} \
\
if (r->h < 0) { \
r->h = 0; \
} \
\
if ((r->x + r->w) > max_w) { \
r->w = max_w - r->x; \
} \
\
if ((r->y + r->h) > max_h) { \
r->h = max_h - r->y; \
} \
\
if (r->w < 0) { \
r->w = 0; \
} \
\
if (r->h < 0) { \
r->h = 0; \
} \
}
ret_t rect_merge(rect_t* dr, const rect_t* r) {
return_value_if_fail(r != NULL && dr != NULL, RET_BAD_PARAMS);
if (r->w > 0 && r->h > 0) {
if (dr->w > 0 && dr->h > 0) {
xy_t x = tk_min(dr->x, r->x);
xy_t y = tk_min(dr->y, r->y);
wh_t right = tk_max((r->x + r->w), (dr->x + dr->w));
wh_t bottom = tk_max((r->y + r->h), (dr->y + dr->h));
dr->x = x;
dr->y = y;
dr->w = right - x;
dr->h = bottom - y;
} else {
*dr = *r;
}
}
return RET_OK;
}
bool_t rect_contains(const rect_t* r, xy_t x, xy_t y) {
return_value_if_fail(r != NULL, FALSE);
return (x >= r->x && x < (r->x + r->w)) && (y >= r->y && y < (r->y + r->h));
}
bool_t rect_has_intersect(const rect_t* r1, const rect_t* r2) {
xy_t right1 = 0;
xy_t right2 = 0;
xy_t bottom1 = 0;
xy_t bottom2 = 0;
return_value_if_fail(r1 != NULL && r2 != NULL, FALSE);
right1 = r1->x + r1->w - 1;
right2 = r2->x + r2->w - 1;
bottom1 = r1->y + r1->h - 1;
bottom2 = r2->y + r2->h - 1;
if (right1 < r2->x || right2 < r1->x || bottom1 < r2->y || bottom2 < r1->y) {
return FALSE;
}
return TRUE;
}
rectf_t rectf_init(float x, float y, float w, float h) {
rectf_t r = {x, y, w, h};
return r;
}
rect_t rect_init(xy_t x, xy_t y, wh_t w, wh_t h) {
rect_t r = {x, y, w, h};
return r;
}
bool_t rect_diff(const rect_t* r1, const rect_t* r2, rect_t* out_r1, rect_t* out_r2, rect_t* out_r3,
rect_t* out_r4) {
#define RECT_DIFF_INIT(r, r_x, r_y, r_w, r_h) \
{ \
(r)->x = (r_x); \
(r)->y = (r_y); \
(r)->w = (r_w); \
(r)->h = (r_h); \
}
rect_t in;
return_value_if_fail(r1 != NULL && r2 != NULL && out_r1 != NULL && out_r2 != NULL &&
out_r3 != NULL && out_r4 != NULL,
FALSE);
memset(out_r1, 0x0, sizeof(rect_t));
memset(out_r2, 0x0, sizeof(rect_t));
memset(out_r3, 0x0, sizeof(rect_t));
memset(out_r4, 0x0, sizeof(rect_t));
in = rect_intersect(r1, r2);
if (in.w == 0 || in.h == 0) {
memcpy(out_r1, r1, sizeof(rect_t));
return TRUE;
} else {
if (memcmp(&in, r1, sizeof(rect_t)) == 0) {
return FALSE;
} else {
int32_t right1 = r1->x + r1->w - 1;
int32_t right2 = r2->x + r2->w - 1;
int32_t bottom1 = r1->y + r1->h - 1;
int32_t bottom2 = r2->y + r2->h - 1;
RECT_DIFF_INIT(out_r1, r1->x, r1->y, r1->w, tk_max(in.y - r1->y, 0));
RECT_DIFF_INIT(out_r2, r1->x, in.y, tk_max(in.x - r1->x, 0), in.h);
RECT_DIFF_INIT(out_r3, in.x + in.w, in.y, tk_max(right1 - right2, 0), in.h);
RECT_DIFF_INIT(out_r4, r1->x, in.y + in.h, r1->w, tk_max(bottom1 - bottom2, 0));
return TRUE;
}
}
}
rect_t rect_intersect(const rect_t* r1, const rect_t* r2) {
int32_t top = 0;
int32_t left = 0;
int32_t bottom = 0;
int32_t right = 0;
int32_t bottom1 = 0;
int32_t right1 = 0;
int32_t bottom2 = 0;
int32_t right2 = 0;
rect_t r = rect_init(0, 0, 0, 0);
return_value_if_fail(r1 != NULL && r2 != NULL, r);
bottom1 = r1->y + r1->h - 1;
bottom2 = r2->y + r2->h - 1;
right1 = r1->x + r1->w - 1;
right2 = r2->x + r2->w - 1;
top = tk_max(r1->y, r2->y);
left = tk_max(r1->x, r2->x);
right = tk_min(right1, right2);
bottom = tk_min(bottom1, bottom2);
r.x = left;
r.y = top;
r.w = right >= left ? (right - left + 1) : 0;
r.h = bottom >= top ? (bottom - top + 1) : 0;
return r;
}
rect_t rect_fix(rect_t* r, wh_t max_w, wh_t max_h) {
rectX_fix;
return *r;
}
rect_t* rect_create(xy_t x, xy_t y, wh_t w, wh_t h) {
rect_t* r = TKMEM_ZALLOC(rect_t);
return_value_if_fail(r != NULL, NULL);
*r = rect_init(x, y, w, h);
return r;
}
rect_t* rect_set(rect_t* r, xy_t x, xy_t y, wh_t w, wh_t h) {
return_value_if_fail(r != NULL, NULL);
*r = rect_init(x, y, w, h);
return r;
}
rect_t* rect_cast(rect_t* rect) {
return_value_if_fail(rect != NULL, NULL);
return rect;
}
ret_t rect_destroy(rect_t* r) {
return_value_if_fail(r != NULL, RET_BAD_PARAMS);
TKMEM_FREE(r);
return RET_OK;
}
rect_t* rect_scale(rect_t* r, float_t scale) {
return_value_if_fail(r != NULL, r);
if (scale != 1.0f) {
r->x = tk_roundi(r->x * scale);
r->y = tk_roundi(r->y * scale);
r->w = tk_roundi(r->w * scale);
r->h = tk_roundi(r->h * scale);
}
return r;
}
rectf_t* rectf_scale(rectf_t* r, float_t scale) {
return_value_if_fail(r != NULL, r);
if (scale != 1.0f) {
r->x = r->x * scale;
r->y = r->y * scale;
r->w = r->w * scale;
r->h = r->h * scale;
}
return r;
}
rectf_t rectf_fix(rectf_t* r, wh_t max_w, wh_t max_h) {
rectX_fix;
return *r;
}
rectf_t rect_to_rectf(const rect_t* r) {
rectf_t tmp_r = {0};
return_value_if_fail(r != NULL, tmp_r);
tmp_r.x = (float_t)(r->x);
tmp_r.y = (float_t)(r->y);
tmp_r.w = (float_t)(r->w);
tmp_r.h = (float_t)(r->h);
return tmp_r;
}
rect_t rect_from_rectf(const rectf_t* r) {
rect_t tmp_r = {0};
return_value_if_fail(r != NULL, tmp_r);
tmp_r.x = tk_roundi(r->x);
tmp_r.y = tk_roundi(r->y);
tmp_r.w = tk_roundi(r->w);
tmp_r.h = tk_roundi(r->h);
return tmp_r;
}
pointf_t pointf_init(float_t x, float_t y) {
pointf_t p = {x, y};
return p;
}
point_t point_init(xy_t x, xy_t y) {
point_t p = {x, y};
return p;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/semaphore.h
|
/**
* File: semaphore.h
* Author: AWTK Develop Team
* Brief: semaphore
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-10-27 Li XianJing <[email protected]> created
*
*/
#ifndef TK_SEMAPHORE_H
#define TK_SEMAPHORE_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class tk_semaphore_t
* 信号量。
*/
struct _tk_semaphore_t;
typedef struct _tk_semaphore_t tk_semaphore_t;
/**
* @method tk_semaphore_create
* 创建信号量对象。
* @param {uint32_t} value 初始值。
* @param {const char*} name 名称。
*
* @return {tk_semaphore_t*} semaphore对象。
*/
tk_semaphore_t* tk_semaphore_create(uint32_t value, const char* name);
/**
* @method tk_semaphore_wait
* 获取资源。
* @param {tk_semaphore_t*} semaphore 信号量对象。
* @param {uint32_t} timeout 超时时间(毫秒)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_semaphore_wait(tk_semaphore_t* semaphore, uint32_t timeout);
/**
* @method tk_semaphore_post
* 释放资源。
* @param {tk_semaphore_t*} semaphore 信号量对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_semaphore_post(tk_semaphore_t* semaphore);
/**
* @method tk_semaphore_destroy
* 销毁信号量对象。
* @param {tk_semaphore_t*} semaphore 信号量对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_semaphore_destroy(tk_semaphore_t* semaphore);
END_C_DECLS
#endif /*TK_SEMAPHORE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source.c
|
/**
* File: event_source.c
* Author: AWTK Develop Team
* Brief: event source interface.
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-29 Li XianJing <[email protected]> created
*
*/
#include "tkc/event_source.h"
int32_t event_source_get_fd(event_source_t* source) {
return_value_if_fail(source != NULL, -1);
return source->get_fd != NULL ? source->get_fd(source) : -1;
}
ret_t event_source_dispatch(event_source_t* source) {
return_value_if_fail(source != NULL && source->dispatch != NULL, RET_BAD_PARAMS);
return source->dispatch(source);
}
ret_t event_source_check(event_source_t* source) {
return_value_if_fail(source != NULL, RET_BAD_PARAMS);
return source->check != NULL ? source->check(source) : RET_FAIL;
}
uint32_t event_source_get_wakeup_time(event_source_t* source) {
return_value_if_fail(source != NULL, 0);
return source->get_wakeup_time != NULL ? source->get_wakeup_time(source) : 0;
}
ret_t event_source_set_tag(event_source_t* source, void* tag) {
return_value_if_fail(source != NULL, RET_BAD_PARAMS);
source->tag = tag;
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_typed_array.h
|
/**
* File: object_typed_array.h
* Author: AWTK Develop Team
* Brief: wrap typed array to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_TYPED_ARRAY_H
#define TK_OBJECT_TYPED_ARRAY_H
#include "tkc/object.h"
#include "tkc/typed_array.h"
BEGIN_C_DECLS
/**
* @class object_typed_array_t
* @parent tk_object_t
*
* 将typed_array包装成object。
*
*/
typedef struct _object_typed_array_t {
tk_object_t object;
/**
* @property {typed_array_t*} arr
* @annotation ["readable"]
* typed array对象。
*
*/
typed_array_t* arr;
} object_typed_array_t;
/**
* @method object_typed_array_create
*
* 创建对象。
*
* @annotation ["constructor"]
* @param {value_type_t} type 元素的类型。
* @param {uint32_t} capacity 数组的初始容量(元素个数)。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_typed_array_create(value_type_t type, uint32_t capacity);
/**
* @method object_typed_array_cast
* 转换为object_typed_array对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_typed_array对象。
*
* @return {object_typed_array_t*} object_typed_array对象。
*/
object_typed_array_t* object_typed_array_cast(tk_object_t* obj);
#define OBJECT_TYPED_ARRAY(obj) object_typed_array_cast(obj)
#define OBJECT_TYPED_ARRAY_TYPE "object_typed_array"
END_C_DECLS
#endif /*TK_OBJECT_TYPED_ARRAY_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/waitable_ring_buffer.h
|
/**
* File: waitable_ring_buffer.h
* Author: AWTK Develop Team
* Brief: waitable_ring_buffer
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-04-02 Li XianJing <[email protected]> created
*
*/
#ifndef TK_WAITABLE_RING_BUFFER_H
#define TK_WAITABLE_RING_BUFFER_H
#include "tkc/mutex.h"
#include "tkc/semaphore.h"
#include "tkc/ring_buffer.h"
BEGIN_C_DECLS
/**
* @class waitable_ring_buffer_t
* waitable ring buffer
*/
typedef struct _waitable_ring_buffer_t {
/*private*/
uint32_t block_size;
ring_buffer_t* ring_buffer;
tk_mutex_t* mutex;
tk_semaphore_t* sema_read;
tk_semaphore_t* sema_write;
} waitable_ring_buffer_t;
/**
* @method waitable_ring_buffer_create
* @annotation ["constructor"]
* 创建waitable_ring_buffer对象。
*
* @param {uint32_t} capacity 容量。
* @param {uint32_t} block_size 块的大小。
*
* @return {waitable_ring_buffer_t*} waitable_ring_buffer对象。
*/
waitable_ring_buffer_t* waitable_ring_buffer_create(uint32_t capacity, uint32_t block_size);
/**
* @method waitable_ring_buffer_read
* 读取数据。
*
* @param {waitable_ring_buffer_t*} rb waitable_ring_buffer对象。
* @param {void*} buff 接收数据的buff。
* @param {uint32_t} size 读取数据的长度(必须等于 block_size)。
* @param {uint32_t} timeout_ms 超时时间(毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_ring_buffer_read(waitable_ring_buffer_t* rb, void* buff, uint32_t size,
uint32_t timeout_ms);
/**
* @method waitable_ring_buffer_write
* 写入数据。
*
* @param {waitable_ring_buffer_t*} rb waitable_ring_buffer对象。
* @param {const void*} buff 要写入的数据。
* @param {uint32_t} size 数据的长度(必须等于 block_size)。
* @param {uint32_t} timeout_ms 超时时间(毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_ring_buffer_write(waitable_ring_buffer_t* rb, const void* buff, uint32_t size,
uint32_t timeout_ms);
/**
* @method waitable_ring_buffer_destroy
* 销毁。
*
* @param {waitable_ring_buffer_t*} rb waitable_ring_buffer对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_ring_buffer_destroy(waitable_ring_buffer_t* rb);
END_C_DECLS
#endif /*TK_WAITABLE_RING_BUFFER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/action_queue.c
|
/**
* File: action_queue.c
* Author: AWTK Develop Team
* Brief: action_queue
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-06 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/action_queue.h"
action_queue_t* action_queue_create(uint16_t capacity) {
uint16_t size = 0;
action_queue_t* q = NULL;
return_value_if_fail(capacity > 1, NULL);
size = sizeof(action_queue_t) + sizeof(qaction_t*) * capacity;
q = (action_queue_t*)TKMEM_ALLOC(size);
return_value_if_fail(q != NULL, NULL);
memset(q, 0x00, size);
q->capacity = capacity;
return q;
}
ret_t action_queue_recv(action_queue_t* q, qaction_t** action) {
return_value_if_fail(q != NULL && action != NULL, RET_BAD_PARAMS);
if (q->r != q->w || q->full) {
*action = q->actions[q->r];
q->actions[q->r] = NULL;
if ((q->r + 1) < q->capacity) {
q->r++;
} else {
q->r = 0;
}
q->full = FALSE;
return RET_OK;
}
return RET_FAIL;
}
ret_t action_queue_send(action_queue_t* q, qaction_t* action) {
return_value_if_fail(q != NULL && action != NULL, RET_BAD_PARAMS);
if (q->r != q->w || !q->full) {
q->actions[q->w] = action;
if ((q->w + 1) < q->capacity) {
q->w++;
} else {
q->w = 0;
}
if (q->r == q->w) {
q->full = TRUE;
}
return RET_OK;
}
return RET_FAIL;
}
ret_t action_queue_destroy(action_queue_t* q) {
uint32_t i = 0;
return_value_if_fail(q != NULL, RET_BAD_PARAMS);
for (i = 0; i < q->capacity; i++) {
if (q->actions[i] != NULL) {
qaction_destroy(q->actions[i]);
}
}
TKMEM_FREE(q);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/utils.h
|
/**
* File: utils.h
* Author: AWTK Develop Team
* Brief: utils struct and utils functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-02-21 Li XianJing <[email protected]> created
*
*/
#ifndef TK_UTILS_H
#define TK_UTILS_H
#include "tkc/str.h"
#include "tkc/rect.h"
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @class utils_t
* @annotation ["fake"]
* 工具类。
*
*/
/**
* @method tk_atoi
*
* 将字符串转换为整型数。
*
* @param {const char*} str 要转换为整型数的字符串。
*
* @return {int32_t} 返回转换后的整型。
*/
int32_t tk_atoi(const char* str);
/**
* @method tk_atol
*
* 将字符串转换为整型。
*
* @param {const char*} str 要转换为整型的字符串。
*
* @return {int64_t} 返回转换后的整型。
*/
int64_t tk_atol(const char* str);
/**
* @method tk_atoul
*
* 将字符串转换为整型。
*
* @param {const char*} str 要转换为整型的字符串。
*
* @return {uint64_t} 返回转换后的整型。
*/
uint64_t tk_atoul(const char* str);
/**
* @method tk_atob
*
* 将字符串转换为布尔类型。
*
* @param {const char*} str 要转换为布尔类型的字符串。
*
* @return {bool_t} 返回转换后的布尔类型。
*/
bool_t tk_atob(const char* str);
/**
* @method tk_atof
*
* 将字符串转换为浮点类型。
*
* @param {const char*} str 要转换为浮点类型的字符串。
*
* @return {double} 返回转换后的浮点类型。
*/
double tk_atof(const char* str);
/**
* @method tk_strcmp
*
* 字符串比较函数。
*
* @param {const char*} a 要进行比较的第一个字符串。
* @param {const char*} b 要进行比较的第二个字符串。
*
* @return {int32_t} 如果返回值=-1，则表示a为NULL；如果返回值=1，则表示b为NULL；如果返回值<0，则表示a小于b；如果返回值>0，则表示a大于b；如果返回值=0，则表示a等于b。
*/
int32_t tk_strcmp(const char* a, const char* b);
/**
* @method tk_stricmp
*
* 字符串比较函数（不区分大小写）。
*
* @param {const char*} a 要进行比较的第一个字符串。
* @param {const char*} b 要进行比较的第二个字符串。
*
* @return {int32_t} 如果返回值=-1，则表示a为NULL；如果返回值=1，则表示b为NULL；如果返回值<0，则表示a小于b；如果返回值>0，则表示a大于b；如果返回值=0，则表示a等于b。
*/
int32_t tk_stricmp(const char* a, const char* b);
/**
* @method tk_wstrcmp
*
* 字符串比较函数。
*
* @param {const wchar_t*} a 要进行比较的第一个字符串。
* @param {const wchar_t*} b 要进行比较的第二个字符串。
*
* @return {int32_t} 如果返回值=-1，则表示a为NULL；如果返回值=1，则表示b为NULL；如果返回值<0，则表示a小于b；如果返回值>0，则表示a大于b；如果返回值=0，则表示a等于b。
*/
int32_t tk_wstrcmp(const wchar_t* a, const wchar_t* b);
/**
* @method tk_wstricmp
*
* 字符串比较函数（不区分大小写）。
*
* @param {const wchar_t*} a 要进行比较的第一个字符串。
* @param {const wchar_t*} b 要进行比较的第二个字符串。
*
* @return {int32_t} 如果返回值=-1，则表示a为NULL；如果返回值=1，则表示b为NULL；如果返回值<0，则表示a小于b；如果返回值>0，则表示a大于b；如果返回值=0，则表示a等于b。
*/
int32_t tk_wstricmp(const wchar_t* a, const wchar_t* b);
/**
* @method tk_watoi
*
* 将宽字符串转换为整型。
*
* @param {const wchar_t*} str 要转换为整型的宽字符串。
*
* @return {int} 返回转换后的整型。
*/
int tk_watoi(const wchar_t* str);
/**
* @method tk_watoi_n
*
* 将宽字符串转换为整型。
*
* @param {const wchar_t*} str 要转换为整型的宽字符串。
* @param {uint32_t} len 字符串长度。
*
* @return {int} 返回转换后的整型。
*/
int tk_watoi_n(const wchar_t* str, uint32_t len);
/**
* @method tk_watob
*
* 将宽字符串转换为布尔类型。
*
* @param {const wchar_t*} str 要转换为布尔类型的宽字符串。
*
* @return {bool_t} 返回转换后的布尔类型。
*/
bool_t tk_watob(const wchar_t* str);
/**
* @method tk_watof
*
* 将宽字符串转换为浮点类型。
*
* @param {const wchar_t*} str 要转换为浮点类型的宽字符串。
*
* @return {double} 返回转换后的浮点类型。
*/
double tk_watof(const wchar_t* str);
/**
* @method tk_skip_to_num
*
* 跳过字符串函数，如：字符串"hello123world"，返回的结果是"123world"。
*
* @param {const char*} str 要输入的原始字符串。
*
* @return {const char*} 返回转换后的字符串。
*/
const char* tk_skip_to_num(const char* str);
/**
* @method tk_itoa
*
* 将整型转换为字符串。
*
* @param {char*} str 保存字符串缓冲区。
* @param {int} len 缓冲区大小。
* @param {int} n 要转换的整型。
*
* @return {const char*} 返回字符串。
*/
const char* tk_itoa(char* str, int len, int n);
/**
* @method tk_lltoa
*
* 将整型转换为字符串。
*
* @param {char*} str 保存字符串缓冲区。
* @param {int} len 缓冲区大小。
* @param {int64_t} n 要转换的整型。
*
* @return {const char*} 返回字符串。
*/
const char* tk_lltoa(char* str, int len, int64_t n);
/**
* @method tk_ftoa
*
* 将浮点型转换为字符串。
*
* @param {char*} str 保存字符串缓冲区。
* @param {int} len 缓冲区大小。
* @param {double} f 要转换的浮点型。
*
* @return {const char*} 返回字符串。
*/
const char* tk_ftoa(char* str, int len, double f);
/**
* @method tk_strtoi
*
* 将字符串转换为整型。
*
* @param {const char*} str 要转换为整型的字符串。
* @param {const char**} end 对类型char*的对象的引用。
* @param {int} base 基数。
*
* @return {int32_t} 返回转换后的整型。
*/
int32_t tk_strtoi(const char* str, const char** end, int base);
/**
* @method tk_strtol
*
* 将字符串转换为长整型。
*
* @param {const char*} str 要转换为长整型的字符串。
* @param {const char**} end 对类型char*的对象的引用。
* @param {int} base 基数。
*
* @return {long} 返回转换后的长整型。
*/
long tk_strtol(const char* str, const char** end, int base);
/**
* @method tk_strtoll
*
* 将字符串转换为长整型。
*
* @param {const char*} str 要转换为长整型的字符串。
* @param {const char**} end 对类型char*的对象的引用。
* @param {int} base 基数。
*
* @return {int64_t} 返回转换后的长整型。
*/
int64_t tk_strtoll(const char* str, const char** end, int base);
/**
* @method tk_strcpy
*
* 将src所指向的字符串复制到dst。
*
* @param {char*} dst 目标字符串。
* @param {const char*} src 原字符串。
*
* @return {char*} 返回目标字符串。
*/
char* tk_strcpy(char* dst, const char* src);
/**
* @method tk_strncpy
*
* 将src所指向的字符串复制到dst，最多复制len个字符串，并在[len]位置添加'\0'。
*
*> 请确保dst的长度>=(len+1)
*
* @param {char*} dst 目标字符串。
* @param {const char*} src 源字符串。
* @param {size_t} len 要复制的字符串个数。
*
* @return {char*} 返回目标字符串。
*/
char* tk_strncpy(char* dst, const char* src, size_t len);
/**
* @method tk_strncpy_s
*
* 将src所指向的字符串复制到dst，最多复制min(dst_len-1, src_len)个字符串，并在[len]位置添加'\0'。
* 如果 dst 和 src 的地址对齐的话，效率会比 strncpy 高，如果小于 64 个字节的话，效率是最高的。
*
* @param {char*} dst 目标字符串。
* @param {size_t} dst_len 目标字符串内存长度。
* @param {const char*} src 源字符串。
* @param {size_t} src_len 要复制的字符串个数。
*
* @return {char*} 返回目标字符串。
*/
char* tk_strncpy_s(char* dst, size_t dst_len, const char* src, size_t src_len);
/**
* @method tk_memdup
*
* 内存拷贝。
*
* @param {const void*} data 原内存。
* @param {uint32_t} len 长度。
*
* @return {void*} 返回指向的向新的内存指针，如果失败则返回NULL。
*/
void* tk_memdup(const void* data, uint32_t len);
/**
* @method tk_strdup
*
* 字符串拷贝函数。
*
* @param {const char*} str 原字符串。
*
* @return {char*} 返回指向的复制字符串指针，如果失败则返回NULL。
*/
char* tk_strdup(const char* str);
/**
* @method tk_wstrdup
*
* 宽字符串拷贝函数。
*
* @param {const wchar_t*} str 原宽字符串。
*
* @return {wchar_t*} 返回指向的复制宽字符串指针，如果失败则返回NULL。
*/
wchar_t* tk_wstrdup(const wchar_t* str);
/**
* @method tk_strndup
*
* 字符串拷贝函数，最多复制len个字符串。
*
* @param {const char*} str 原字符串。
* @param {uint32_t} len 要复制的字符串个数。
*
* @return {char*} 返回指向的复制字符串指针，如果失败则返回NULL。
*/
char* tk_strndup(const char* str, uint32_t len);
/**
* @method tk_strlen
*
* 获取字符串的长度。str为空时返回0。
*
* @param {const char*} str 字符串。
*
* @return {uint32_t} 返回字符串的长度。
*/
uint32_t tk_strlen(const char* str);
/**
* @method tk_strnlen
*
* 获取字符串的长度。str为空时返回0。
*
* @param {const char*} str 字符串。
* @param {uint32_t} maxlen 最大长度。
*
* @return {uint32_t} 返回字符串的长度。
*/
uint32_t tk_strnlen(const char* str, uint32_t maxlen);
/**
* @method tk_strrstr
*
* 从后往前查找指定的字符串。
*
* @param {const char*} str 字符串。
* @param {const char*} substr 子字符串。
*
* @return {const char*} 返回字符串的位置或者NULL。
*/
const char* tk_strrstr(const char* str, const char* substr);
/**
* @method tk_str_append
*
* 字符串追加函数。
*
* @param {char*} str 被追加字符串。
* @param {uint32_t} max_len 字符串的最大长度。
* @param {const char*} s 要追加的字符串。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_str_append(char* str, uint32_t max_len, const char* s);
/**
* @method tk_memset16
*
* 设置数据2字节。
*
* @param {uint16_t*} buff buff
* @param {uint16_t} val 值。
* @param {uint32_t} size 个数。
*
* @return {uint16_t*} 返回设置好的buff。
*/
uint16_t* tk_memset16(uint16_t* buff, uint16_t val, uint32_t size);
/**
* @method tk_memset24
*
* 设置数据3字节。
*
* @param {uint32_t*} buff buff。
* @param {void*} val 值。
* @param {uint32_t} size 个数。
*
* @return {uint32_t*} 返回设置好的buff。
*/
uint32_t* tk_memset24(uint32_t* buff, void* val, uint32_t size);
/**
* @method tk_memset32
*
* 设置数据4字节。
*
* @param {uint32_t*} buff buff。
* @param {uint32_t} val 值。
* @param {uint32_t} size 个数。
*
* @return {uint32_t*} 返回设置好的buff。
*/
uint32_t* tk_memset32(uint32_t* buff, uint32_t val, uint32_t size);
/**
* @method tk_memcpy16
*
* 拷贝数据2字节。
*
* @param {uint16_t*} dst 目标
* @param {uint16_t*} src 源。
* @param {uint32_t} size 个数。
*
* @return {uint16_t*} 返回设置好的buff。
*/
uint16_t* tk_memcpy16(uint16_t* dst, uint16_t* src, uint32_t size);
/**
* @method tk_memcpy32
*
* 拷贝数据4字节。
*
* @param {uint32_t*} dst 目标
* @param {uint32_t*} src 源。
* @param {uint32_t} size 个数。
*
* @return {uint32_t*} 返回设置好的buff。
*/
uint32_t* tk_memcpy32(uint32_t* dst, uint32_t* src, uint32_t size);
/**
* @method tk_pixel_copy
*
* 已bpp字节为标准拷贝数据。
*
* @param {void*} dst 目标
* @param {const void*} src 源。
* @param {uint32_t} size 个数。
* @param {uint8_t} bpp 单个数据的字节数。
*
* @return {void*} 返回设置好的buff。
*/
void* tk_pixel_copy(void* dst, const void* src, uint32_t size, uint8_t bpp);
/**
* @method tk_snprintf
*
* 将可变参数(...)按照format格式化字符串，并将字符串复制到str中。
*
* @param {char*} str 目标字符串。
* @param {size_t} size 拷贝字节数。
* @param {const char*} format 格式化字符串。
*
* @return {int} 返回格式化后的字符串长度。
*/
int tk_snprintf(char* str, size_t size, const char* format, ...);
/**
* @method tk_vsnprintf
*
* 将可变参数ap按照format格式化字符串，并将字符串复制到str中。
*
* @param {char*} str 目标字符串。
* @param {size_t} size 拷贝字节数。
* @param {const char*} format 格式化字符串。
* @param {va_list} ap 可变参数。
*
* @return {int} 返回格式化后的字符串长度。
*/
int tk_vsnprintf(char* str, size_t size, const char* format, va_list ap);
/**
* @method tk_sscanf
*
* 从字符串读取格式化输入。
*
* @param {const char*} str 要输入的字符串。
* @param {const char*} format 格式化字符串。
*
* @return {int} 返回成功匹配和赋值的个数。
*/
int tk_sscanf(const char* str, const char* format, ...);
/**
* @method filename_to_name
*
* 从完整文件名中获取文件名。
*
* @param {const char*} filename 完整的文件名。
* @param {char*} str 用于返回文件名。
* @param {uint32_t} size 文件名(str参数)的最大长度。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t filename_to_name(const char* filename, char* str, uint32_t size);
/**
* @method filename_to_name_ex
*
* 从完整文件名中获取文件名。
*
* @param {const char*} filename 完整的文件名。
* @param {char*} str 用于返回文件名。
* @param {uint32_t} size 文件名(str参数)的最大长度。
* @param {bool_t} remove_extname 是否移除扩展名。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t filename_to_name_ex(const char* filename, char* str, uint32_t size, bool_t remove_extname);
/**
* @method xml_file_expand_read
*
* expand include process instruction to file content: <?include filename="view_me.inc" ?>
*
* @param {const char*} filename 文件名。
* @param {str_t*} s 用于返回内容。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t xml_file_expand_read(const char* filename, str_t* s);
/**
* @method xml_file_expand_subfilenames_get
*
* 从xml文件中获取所有使用 <?include filename="" ?> 导入的文件名称
*
* @param {const char*} filename 文件名。
* @param {char***} subfilenames 用于返回文件名称集合。
* @param {uint32_t*} size 用于返回文件名称集合的大小。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t xml_file_expand_subfilenames_get(const char* filename, char*** subfilenames, uint32_t* size);
/**
* @method tk_str_copy
*
* 字符串拷贝函数。
* > XXX: 要求dst为NULL或内存块的首地址，本函数调用之后，dst可能无效，请保留返回的地址
* 该函数会自动申请内存，调用后需要使用TKMEM_FREE释放。
*
* @param {char*} dst 目标字符串。
* @param {const char*} src 源字符串。
*
* @return {char*} 返回指向的复制字符串指针，如果失败则返回NULL。
*/
char* tk_str_copy(char* dst, const char* src);
/**
* @method dummy_destroy
*
* 空的destroy函数。
* @param {void*} data 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t dummy_destroy(void* data);
/**
* @method default_destroy
*
* 缺省的destroy函数。释放data指向的内存。
* @param {void*} data 数据。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t default_destroy(void* data);
/**
* @method pointer_compare
*
* 指针比较。
*
* @param {const void*} a 数据a。
* @param {const void*} b 数据b。
*
* @return {int} 返回0表示相等，返回负数表示小于，返回整数表示大于。
*/
int pointer_compare(const void* a, const void* b);
/**
* @method compare_always_equal
*
* 始终返回相等。
*
* @param {const void*} a 数据a。
* @param {const void*} b 数据b。
*
* @return {int} 始终返回0。
*/
int compare_always_equal(const void* a, const void* b);
/**
* @method tk_is_valid_name
*
* 判断是否是有效的属性名。
*
* @param {const char*} name 名字字符串。
*
* @return {bool_t} 如果名称有效返回TRUE，否则返回FALSE。
*/
bool_t tk_is_valid_name(const char* name);
/**
* @method tk_str_start_with
*
* 检查字符串是否以指定的字符串prefix开头。
*
* @param {const char*} str 要检查字符串。
* @param {const char*} prefix 被检查的字符串。
*
* @return {bool_t} 返回TRUE表示是；否则表示不是。
*/
bool_t tk_str_start_with(const char* str, const char* prefix);
/**
* @method tk_str_end_with
*
* 检查字符串是否以指定的字符串appendix结尾。
*
* @param {const char*} str 要检查字符串。
* @param {const char*} appendix 被检查的字符串。
*
* @return {bool_t} 返回TRUE表示是；否则表示不是。
*/
bool_t tk_str_end_with(const char* str, const char* appendix);
/**
* @method tk_str_case_start_with
*
* 检查字符串是否以指定的字符串prefix开头(忽略大小写)。
*
* @param {const char*} str 要检查字符串。
* @param {const char*} prefix 被检查的字符串。
*
* @return {bool_t} 返回TRUE表示是；否则表示不是。
*/
bool_t tk_str_case_start_with(const char* str, const char* prefix);
/**
* @method tk_str_case_end_with
*
* 检查字符串是否以指定的字符串appendix结尾(忽略大小写)。
*
* @param {const char*} str 要检查字符串。
* @param {const char*} appendix 被检查的字符串。
*
* @return {bool_t} 返回TRUE表示是；否则表示不是。
*/
bool_t tk_str_case_end_with(const char* str, const char* appendix);
/**
* @method tk_under_score_to_camel
*
* 将下划线名字转成驼峰名字。
*
* @param {const char*} name 下划线名字。
* @param {char*} out 驼峰名字(保存结果)。
* @param {uint32_t} max_out_size 结果最大长度。
*
* @return {const char* } 返回T驼峰名字。
*/
const char* tk_under_score_to_camel(const char* name, char* out, uint32_t max_out_size);
/**
* @method tk_pointer_to_int
*
* 将指针转换成int。
*
*>与tk_pointer_from_int配套使用，也就是pointer本身必须就是整数，而不是指针，否则pointer会被截断。
*
*
* @param {const void*} p 指针。
*
* @return {int32_t} 返回对应的int数据。
*/
int32_t tk_pointer_to_int(const void* p);
/**
* @method tk_pointer_from_int
*
* 将int转换成指针。
*
* > 常用于将int类型的数据作为回调函数的ctx。
*
* @param {int32_t} v 整数。
*
* @return {void*} 返回对应的指针。
*/
void* tk_pointer_from_int(int32_t v);
/**
* @method tk_pointer_to_long
*
* 将指针转换成long。
*
*>与tk_pointer_from_long配套使用，也就是pointer本身必须就是整数，而不是指针，否则pointer会被截断。
*
*
* @param {const void*} p 指针。
*
* @return {uint64_t} 返回对应的long数据。
*/
uint64_t tk_pointer_to_long(const void* p);
/**
* @method tk_pointer_from_long
*
* 将long转换成指针。
*
* > 常用于将long类型的数据作为回调函数的ctx。
*
* @param {uint64_t} v 整数。
*
* @return {void*} 返回对应的指针。
*/
void* tk_pointer_from_long(uint64_t v);
/**
* @method tk_str_toupper
*
* 将小写字母转换为大写字母。
* >修改传入的字符串。
*
* @param {char*} str 要被转换成大写字母的字符串。
*
* @return {char*} 返回转换后的大写字母字符串。
*/
char* tk_str_toupper(char* str);
/**
* @method tk_str_totitle
*
* 将单词首字母转换为大写字母。
* >修改传入的字符串。
*
* @param {char*} str 被转换的字符串。
*
* @return {char*} 返回转换后的字符串。
*/
char* tk_str_totitle(char* str);
/**
* @method tk_str_tolower
*
* 将大写字母转换为小写字母。
* >修改传入的字符串。
*
* @param {char*} str 要被转换成小写字母的字符串。
*
* @return {char*} 返回转换后的小写字母字符串。
*/
char* tk_str_tolower(char* str);
/**
* @method tk_wstr_dup_utf8
*
* 将utf8字符串拷贝为UCS字符串。
*
* @param {const char*} str utf8编码的字符串。
*
* @return {wchar_t*} 返回UCS字符串(需要调用TKMEM_FREE释放)。
*/
wchar_t* tk_wstr_dup_utf8(const char* str);
/**
* @method tk_utf8_dup_wstr
*
* 将UCS字符串拷贝为utf8字符串。
*
* @param {const wchar_t*} str 字符串。
*
* @return {char*} 返回UTF-8字符串(需要调用TKMEM_FREE释放)。
*/
char* tk_utf8_dup_wstr(const wchar_t* str);
/**
* @method tk_wstr_count_c
*
* 统计UCS字符串中某个字符出现的次数。
*
* @param {const wchar_t*} str 字符串。
* @param {wchar_t} c 字符。
*
* @return {uint32_t} 返回字符出现的次数。
*/
uint32_t tk_wstr_count_c(const wchar_t* str, wchar_t c);
/**
* @method tk_wstr_select_word
* @export none
* 获取字符串中距离某个位置最近的单词（中文或英文字符）或数字字符的范围，选取的范围由标点符号或空格分隔开，得到的范围由left与right两个指针获取。
*
* @param {const wchar_t*} str 字符串。
* @param {uint32_t} len 字符串的长度。
* @param {uint32_t} index 字符串中某个位置的下标。
* @param {int32_t*} left int32_t指针，用来获取范围结果的左边界值
* @param {int32_t*} right int32_t指针，用来获取范围结果的右边界值
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_wstr_select_word(const wchar_t* str, uint32_t len, uint32_t index, int32_t* left,
int32_t* right);
/**
* @method image_region_parse
*
* 解析子图的区域信息。
*
* @param {uint32_t} img_w 图片宽度。
* @param {uint32_t} img_h 图片宽度。
* @param {const char*} region region。
* @param {rect_t*} r 返回具体位置。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t image_region_parse(uint32_t img_w, uint32_t img_h, const char* region, rect_t* r);
/**
* @method object_to_json
* 将对象转换成json字符串。
*
* @param {tk_object_t*} obj object对象。
* @param {str_t*} str 用于返回结果。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_to_json(tk_object_t* obj, str_t* str);
/**
* @method data_url_copy
*
* 将数据从源URL拷贝到目标URL。
*
* @param {const char*} dst_url 目标URL。
* @param {const char*} src_url 源URL。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t data_url_copy(const char* dst_url, const char* src_url);
/**
* @method tk_qsort
*
* 快速排序。
*
* @param {void**} array 数据。
* @param {size_t} nr 元素个数。
* @param {tk_compare_t} cmp 比较函数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_qsort(void** array, size_t nr, tk_compare_t cmp);
/**
* @method tk_str_is_in_array
*
* 检查字符串是否在字符串数组中。
*
* @param {const char*} str 字符串。
* @param {const char**} str_array 字符串数组。
* @param {uint32_t} array_size 字符串数组中字符串的个数。
*
* @return {bool_t} 返回TRUE表示在，否则表示不在。
*/
bool_t tk_str_is_in_array(const char* str, const char** str_array, uint32_t array_size);
/**
* @method tk_int_is_in_array
*
* 检查整数是否在整数数组中。
*
* @param {int32_t} v 整数。
* @param {const int32_t*} array 整数数组。
* @param {uint32_t} array_size 整数数组中整数的个数。
*
* @return {bool_t} 返回TRUE表示在，否则表示不在。
*/
bool_t tk_int_is_in_array(int32_t v, const int32_t* array, uint32_t array_size);
/**
* @method tk_memcpy
*
* 内存拷贝。
* 在地址对齐的情况下并且少于 64 个字节，效率会比 memcpy 要快，否则会退化为 memcpy。
*
* @param {void*} dst 目标字符串。
* @param {const void*} src 源字符串。
* @param {uint32_t} len 拷贝长度。
*
* @return {void*} 返回成功返回 dst 地址，失败返回 NULL。
*/
void* tk_memcpy(void* dst, const void* src, uint32_t len);
void* tk_memcpy_by_align_4(void* dst_align_4, const void* src_align_4, uint32_t len);
static inline int32_t tk_max_int(int32_t a, int32_t b) {
return tk_max(a, b);
}
static inline int32_t tk_min_int(int32_t a, int32_t b) {
return tk_min(a, b);
}
static inline float tk_max_float(float a, float b) {
return tk_max(a, b);
}
static inline float tk_min_float(float a, float b) {
return tk_min(a, b);
}
/**
* @method tk_wild_card_match
*
* 简单的通配符匹配。*匹配0到多个字符，?匹配1个字符。
* 示例：
*
* ```c
* tk_wild_card_match("*c", "abc");
* tk_wild_card_match("a?c", "abc");
* ```
*
* @param {const char*} pattern 字符串。
* @param {const char*} str 字符串。
*
* @return {bool_t} 返回TRUE表示匹配，否则表示不匹配。
*/
bool_t tk_wild_card_match(const char* pattern, const char* str);
/**
* @method tk_eval_ratio_or_px
*
* 如果expr以px/PX结束，直接返回expr前面的数值。
* 如果expr以%结束，而且数值大于1，返回(数值 * value)/100。
* 否则将数值当作比例，返回(数值 * value)。
*
* > 为了兼容以前的处理，如果expr以%结束，但是数值在0到1之间，此时忽略%。
*
* ```c
* tk_eval_ratio_or_px("0.5", 100) => 50
* tk_eval_ratio_or_px("20px", 100) => 20
* tk_eval_ratio_or_px("20%", 100) => 20
* tk_eval_ratio_or_px("0.5%", 100) => 50
* ```
*
* @param {const char*} expr 表达式(如100px, 0.5等)
* @param {int32_t} value 值。
*
* @return {float_t} 返回计算结果。
*/
float_t tk_eval_ratio_or_px(const char* expr, int32_t value);
/**
* @method tk_replace_char
*
* 替换字符。
*
* @param {char*} str 原字符串。
* @param {char} from 被替换的字符。
* @param {char} to 替换成的字符。
*
* @return {char*} 返回str。
*/
char* tk_replace_char(char* str, char from, char to);
/**
* @method tk_is_ui_thread
*
* 判断当前线程是否是UI线程。
*
* @return {bool_t} 返回TRUE表示是，否则表示否。
*/
bool_t tk_is_ui_thread(void);
/**
* @method tk_set_ui_thread
* 设置UI线程的ID。
* @param {uint64_t} ui_thread_id UI线程的ID。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_set_ui_thread(uint64_t ui_thread_id);
/**
* @method tk_replace_locale
* 将文本中的$locale$替换为对应的语言。
* @param {const char*} name 文本。
* @param {char*} out 替换后保存的字符串。
* @param {const char*} locale 语言。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_replace_locale(const char* name, char out[TK_NAME_LEN + 1], const char* locale);
/**
* @method tk_normalize_key_name
* 标准化key_name
* @param {const char*} name key_name。
* @param {char*} fixed_name 保存标准化后的字符串。
*
* @return {const char*} 返回标准化后的字符串。
*/
const char* tk_normalize_key_name(const char* name, char fixed_name[TK_NAME_LEN + 1]);
/**
* @method file_read_as_unix_text
* 读取文本文件。并将windows换行(\r\n)或macos换行(\r)转换为uinux换行(\n)。
*
* @param {const char*} filename 文件名。
* @param {uint32_t*} size 返回实际读取的长度。
*
* @return {char*} 返回读取的数据，需要调用TKMEM_FREE释放。
*/
char* file_read_as_unix_text(const char* filename, uint32_t* size);
/**
* @method ret_code_to_name
* 将ret_t转换成对应的文本名称。
*
* @param {ret_t} ret 代码。
*
* @return {const char*} 返回对应的名称。
*/
const char* ret_code_to_name(ret_t ret);
/**
* @method ret_code_from_name
* 将ret_t的文本名称转换成对应的值。
* @param {const char*} name 字符串。
*
* @return {ret_t} 返回对应的值。
*/
ret_t ret_code_from_name(const char* name);
/**
* @method bits_stream_get
* 从buff中获取第index位的值。
* @param {const uint8_t*} buff 数据。
* @param {uint32_t} size 数据长度。
* @param {uint32_t} index 位索引。
* @param {bool_t*} value 返回值。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t bits_stream_get(const uint8_t* buff, uint32_t size, uint32_t index, bool_t* value);
/**
* @method bits_stream_set
* 设置buff中第index位的值。
* @param {uint8_t*} buff 数据。
* @param {uint32_t} size 数据长度。
* @param {uint32_t} index 位索引。
* @param {bool_t} value 值。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t bits_stream_set(uint8_t* buff, uint32_t size, uint32_t index, bool_t value);
/**
* @method tk_to_utf8_argv
* 将宽字符串数组转换成utf8字符串数组。
* @param {int} argc 参数个数。
* @param {wchar_t**} argv 参数。
* @return {char**} 返回utf8字符串数组。
*/
char** tk_to_utf8_argv(int argc, wchar_t** argv);
/**
* @method tk_free_utf8_argv
* 释放utf8字符串数组。
* @param {int} argc 参数个数。
* @param {char**} argv 参数。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_free_utf8_argv(int argc, char** argv);
/**
* @method tk_sscanf_simple
*
* 从字符串读取格式化输入。
* >TKC自己实现的，只支持几种简单的格式，在没有sscanf函数时使用。
*
* @param {const char*} str 要输入的字符串。
* @param {const char*} format 格式化字符串。
*
* @return {int} 返回成功匹配和赋值的个数。
*/
int tk_sscanf_simple(const char* str, const char* format, ...);
/**
* @method tk_levelize
* 将value转换成level。
* 比如levels为"0-20;21-40;41-60;61-80;81-100"，value为50，那么返回2。
* @param {const char*} levels 级别字符串。
* @param {int32_t} value 值。
* @return {int32_t} 返回level。
*/
int32_t tk_levelize(const char* levels, int32_t value);
/**
* @method tk_count_char
* 统计字符串中某个字符出现的次数。
* @param {const char*} str 字符串。
* @param {char} c 字符。
* @return {uint32_t} 返回字符出现的次数。
*/
uint32_t tk_count_char(const char* str, char c);
/**
* @method tk_date_time_format
* 格式化时间。
* 格式规则：
* * Y 代表年(完整显示)
* * M 代表月(1-12)
* * D 代表日(1-31)
* * h 代表时(0-23)
* * H 代表时(1-12)
* * m 代表分(0-59)
* * s 代表秒(0-59)
* * YY 代表年(只显示末两位)
* * MM 代表月(01-12)
* * DD 代表日(01-31)
* * hh 代表时(00-23)
* * HH 代表时(01-12)
* * mm 代表分(00-59)
* * ss 代表秒(00-59)
*
* 如 日期时间为：2018/11/12 9:10:20
* * "Y/M/D"显示为"2018/11/12"
* * "Y-M-D"显示为"2018-11-12"
* * "Y-M-D h:m:s"显示为"2018-11-12 9:10:20"
* * "Y-M-D hh:mm:ss"显示为"2018-11-12 09:10:20"
*
* @param {uint64_t} time 时间。
* @param {const char*} format 格式化字符串。
* @param {str_t*} result 用于返回结果。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_date_time_format(uint64_t time, const char* format, str_t* result);
/**
* @method tk_bits_to_bytes
* 将bits数转换成bytes数。
* @param {uint32_t} bits bits。
* @return {uint32_t} 返回bytes。
*/
uint32_t tk_bits_to_bytes(uint32_t bits);
/**
* @method tk_bits_data_from_bytes_data
* 将bytes数据转换成bits数据(每个字节对应一位)。
* @param {uint8_t*} bits bits。
* @param {uint32_t} bits_size bits内存的长度(字节数)。
* @param {uint8_t*} bytes bytes。
* @param {uint32_t} bytes_size bytes内存的长度(字节数)。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_bits_data_from_bytes_data(uint8_t* bits, uint32_t bits_size, uint8_t* bytes,
uint32_t bytes_size);
/**
* @method tk_bits_data_to_bytes_data
* 将bits数据转换成bytes数据(每个字节对应一位)。
* @param {uint8_t*} bits bits。
* @param {uint32_t} bits_size bits内存的长度(字节数)。
* @param {uint8_t*} bytes bytes。
* @param {uint32_t} bytes_size bytes内存的长度(字节数)。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_bits_data_to_bytes_data(uint8_t* bits, uint32_t bits_size, uint8_t* bytes,
uint32_t bytes_size);
/**
* @method tk_buffer_set_value
* 设置buffer中的值。
* @param {uint8_t*} buffer buffer。
* @param {uint32_t} size buffer的长度。
* @param {value_type_t} type 类型。
* @param {int16_t} offset 偏移。
* @param {int16_t} bit_offset 位偏移。
* @param {const value_t*} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_buffer_set_value(uint8_t* buffer, uint32_t size, value_type_t type, int16_t offset,
int16_t bit_offset, const value_t* value);
/**
* @method tk_buffer_get_value
* 获取buffer中的值。
* @param {uint8_t*} buffer buffer。
* @param {uint32_t} size buffer的长度。
* @param {value_type_t} type 类型。
* @param {int16_t} offset 偏移。
* @param {int16_t} bit_offset 位偏移。
* @param {value_t*} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_buffer_get_value(uint8_t* buffer, uint32_t size, value_type_t type, int16_t offset,
int16_t bit_offset, value_t* value);
/**
* @method tk_size_of_basic_type
* 获取基本类型的大小(字节数)。
* @param {value_type_t} type 类型。
* @return {uint32_t} 返回大小。
*/
uint32_t tk_size_of_basic_type(value_type_t type);
/**
* @method tk_basic_type_from_name
* 将类型名称转换成对应的类型。
* @param {const char*} type 类型名称。
* @return {value_type_t} 返回对应的类型。
*/
value_type_t tk_basic_type_from_name(const char* type);
/**
* @method tk_distance
* 计算两点之间的距离。
* @param {int} x1 x1。
* @param {int} y1 y1。
* @param {int} x2 x2。
* @param {int} y2 y2。
* @return {uint32_t} 返回距离。
*/
uint32_t tk_distance(int x1, int y1, int x2, int y2);
/**
* @method tk_value_to_angle
* 将value转换成角度。
* @param {double} value 值。
* @param {double} min 最小值。
* @param {double} max 最大值。
* @param {double} start_angle 开始角度。
* @param {double} end_angle 结束角度。
* @param {bool_t} counter_clock_wise 是否逆时针。
* @return {double} 返回角度。
*/
double tk_value_to_angle(double value, double min, double max, double start_angle, double end_angle,
bool_t counter_clock_wise);
/**
* @method tk_angle
* 计算两点之间的角度(逆时针方向为正，GUI坐标)。
* @param {int} cx cx。
* @param {int} cy cy。
* @param {int} x x。
* @param {int} y y。
*
* @return {double} 返回角度。
*/
double tk_angle(int cx, int cy, int x, int y);
/**
* @method tk_skip_chars
* 跳过字符串中的字符。
* @param {const char*} str 字符串。
* @param {const char*} chars 字符集。
*
* @return {const char*} 返回跳过后的字符串。
*/
const char* tk_skip_chars(const char* str, const char* chars);
/**
* @method tk_skip_to_chars
* 跳到字符串中的字符。
* @param {const char*} str 字符串。
* @param {const char*} chars 字符集。
*
* @return {const char*} 返回跳到的字符串。
*/
const char* tk_skip_to_chars(const char* str, const char* chars);
/**
* @method tk_mergesort
* 归并排序(如果需要稳定的排序，可以选择归并排序，而不是快速排序)。
* @param {void*} base 数据。
* @param {size_t} nmemb 元素个数。
* @param {size_t} size 元素大小。
* @param {tk_compare_t} cmp 比较函数。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t tk_mergesort(void* base, size_t nmemb, size_t size, tk_compare_t cmp);
#define TK_STRDUP(str) ((str) != NULL) ? tk_strdup(str) : NULL
#define TK_STRNDUP(str, len) ((str) != NULL) ? tk_strndup(str, len) : NULL
#define tk_str_cmp tk_strcmp
#define tk_str_icmp tk_stricmp
#if defined(WIN32) && !defined(MINGW)
#define MAIN() \
int wmain(int argc, wchar_t* wargv[]) { \
char** argv = tk_to_utf8_argv(argc, wargv);
#define END_MAIN(code) \
tk_free_utf8_argv(argc, argv); \
return code; \
}
#define MAIN_RETURN(code) \
tk_free_utf8_argv(argc, argv); \
return code;
#else
#define MAIN() int main(int argc, char* argv[]) {
#define MAIN_RETURN(code) return code;
#define END_MAIN(code) \
return code; \
}
#endif
/*public for test*/
ret_t xml_file_expand(const char* filename, str_t* s, const char* data);
END_C_DECLS
#endif /*TK_UTILS_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_hash.h
|
/**
* File: object_hash.h
* Author: AWTK Develop Team
* Brief: 用散列值查询属性的object
*
* Copyright (c) 2024 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2024-08-19 Shen ZhaoKun <[email protected]> created
*
*/
#ifndef TK_OBJECT_HASH_H
#define TK_OBJECT_HASH_H
#include "tkc/object.h"
#include "tkc/darray.h"
BEGIN_C_DECLS
/**
* @class object_hash_t
* @parent tk_object_t
* @annotation ["scriptable"]
*
* 对象接口的散列值查询属性的object实现。
*
* 通用当作 map 数据结构使用，内部用有序数组保存所有属性，因此可以快速查找指定名称的属性。
*
* 示例
*
*```c
* // 创建默认对象
* tk_object_t *obj = object_hash_create();
*
* // 设置属性
* tk_object_set_prop_str(obj, "name", "awplc");
* tk_object_set_prop_int(obj, "age", 18);
* tk_object_set_prop_double(obj, "weight", 60.5);
*
* // 获取属性
* ENSURE(tk_str_eq(tk_object_get_prop_str(obj, "name"), "awplc"));
* ENSURE(tk_object_get_prop_int(obj, "age", 0) == 18);
* ENSURE(tk_object_get_prop_double(obj, "weight", 0) == 60.5);
*
* // 遍历属性
* tk_object_foreach_prop(obj, visit_obj, NULL);
*
* // 释放对象
* TK_OBJECT_UNREF(obj);
*```
*/
typedef struct _object_hash_t {
tk_object_t object;
/*private*/
darray_t props;
bool_t enable_path : 1;
/*设置属性值不改变属性的类型*/
bool_t keep_prop_type : 1;
} object_hash_t;
/**
* @method object_hash_create
*
* 创建对象。
*
* @annotation ["constructor", "scriptable", "gc"]
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_hash_create(void);
/**
* @method object_hash_create_ex
*
* 创建对象。
*
* @annotation ["constructor", "scriptable", "gc"]
* @param {bool_t} enable_path 是否支持按路径访问属性。
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_hash_create_ex(bool_t enable_path);
/**
* @method object_hash_set_keep_prop_type
* 设置属性值时不改变属性的类型。
* @annotation ["scriptable"]
* @param {tk_object_t*} obj 对象。
* @param {bool_t} keep_prop_type 不改变属性的类型。
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t object_hash_set_keep_prop_type(tk_object_t* obj, bool_t keep_prop_type);
/**
* @method object_hash_cast
* 转换为object_hash对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_hash对象。
*
* @return {object_hash_t*} object_hash对象。
*/
object_hash_t* object_hash_cast(tk_object_t* obj);
#define OBJECT_HASH(obj) object_hash_cast(obj)
#define OBJECT_HASH_TYPE "object_hash"
END_C_DECLS
#endif /*TK_OBJECT_HASH_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/async.h
|
/**
* File: async.h
* Author: AWTK Develop Team
* Brief: async
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ===============================================================
* 2019-05-11 Li XianJing <[email protected]> created
*
*/
#ifndef TK_ASYNC_H
#define TK_ASYNC_H
#include "tkc/types_def.h"
BEGIN_C_DECLS
typedef ret_t (*async_exec_t)(void* ctx);
typedef ret_t (*async_on_result_t)(void* ctx, ret_t result);
/**
* @class async_t
* 在后台线程执行指定函数，不会阻塞UI线程。
*
* @annotation ["fake"]
*
*/
/**
* @method async_call
* 异步执行exec函数，执行完成后，在后台线程调用on_result函数。
*
* @annotation ["static"]
*
* @param {async_exec_t} exec 需要异步支持的函数。
* @param {async_on_result_t} on_result 返回执行结果(可选)
* @param {void*} ctx 两个回调函数的上下文。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t async_call(async_exec_t exec, async_on_result_t on_result, void* ctx);
/**
* @method async_call_init_ex
* 全局初始化。
*
* @annotation ["static"]
* @param {uint32_t} max_threads 最大线程数。
* @param {uint32_t} min_threads 最小线程数(必须大于0)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t async_call_init_ex(uint32_t max_threads, uint32_t min_threads);
/**
* @method async_call_init_ex2
* 全局初始化。
*
* @annotation ["static"]
* @param {uint32_t} max_threads 最大线程数。
* @param {uint32_t} min_threads 最小线程数(必须大于0)。
* @param {uint32_t} stack_size 栈空间大小(字节)。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t async_call_init_ex2(uint32_t max_threads, uint32_t min_threads, uint32_t stack_size);
#define async_call_init() async_call_init_ex(5, 1)
/**
* @method async_call_deinit
* 全局~初始化。
*
* @annotation ["static"]
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*
*/
ret_t async_call_deinit(void);
END_C_DECLS
#endif /*TK_ASYNC_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_compositor.h
|
/**
* File: object_compositor.h
* Author: AWTK Develop Team
* Brief: compositor two objects into one
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-20 Li XianJing <[email protected]> created
*
*/
#ifndef TK_OBJECT_COMPOSITOR_H
#define TK_OBJECT_COMPOSITOR_H
#include "tkc/object.h"
BEGIN_C_DECLS
/**
* @class object_compositor_t
* @parent tk_object_t
*
* 将两个对象包装为一个对象，优先访问第一个对象，如果访问失败则访问第二个对象。
*
*/
typedef struct _object_compositor_t {
tk_object_t object;
/*private*/
tk_object_t* obj1;
tk_object_t* obj2;
} object_compositor_t;
/**
* @method object_compositor_create
*
* 创建对象。
*
* @annotation ["constructor"]
*
* @param {tk_object_t*} obj1 对象1。
* @param {tk_object_t*} obj2 对象2。
*
* @return {tk_object_t*} 返回object对象。
*
*/
tk_object_t* object_compositor_create(tk_object_t* obj1, tk_object_t* obj2);
/**
* @method object_compositor_cast
* 转换为object_compositor对象。
* @annotation ["cast"]
* @param {tk_object_t*} obj object_compositor对象。
*
* @return {object_compositor_t*} object_compositor对象。
*/
object_compositor_t* object_compositor_cast(tk_object_t* obj);
#define OBJECT_COMPOSITOR(obj) object_compositor_cast(obj)
#define OBJECT_COMPOSITOR_TYPE "object_compositor"
END_C_DECLS
#endif /*TK_OBJECT_COMPOSITOR_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/named_value.h
|
/**
* File: named_value.h
* Author: AWTK Develop Team
* Brief: named value
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-10 Li XianJing <[email protected]> created
*
*/
#ifndef TK_NAMED_VALUE_H
#define TK_NAMED_VALUE_H
#include "tkc/value.h"
BEGIN_C_DECLS
/**
* @class named_value_t
* @annotation ["scriptable"]
* 命名的值。
*
*/
typedef struct _named_value_t {
/**
* @property {char*} name
* @annotation ["readable", "scriptable"]
* 名称。
*/
char* name;
/**
* @property {value_t} value
* @annotation ["readable"]
* 值。
*/
value_t value;
} named_value_t;
/**
* @method named_value_create
*
* 创建named_value对象。
* @annotation ["constructor", "scriptable", "gc"]
*
* @return {named_value_t*} 返回named_value对象。
*/
named_value_t* named_value_create(void);
/**
* @method named_value_create_ex
*
* 创建named_value对象。
* @annotation ["constructor"]
*
* @param {const char*} name 名称。
* @param {const value_t*} value 值。
*
* @return {named_value_t*} 返回named_value对象。
*/
named_value_t* named_value_create_ex(const char* name, const value_t* value);
/**
* @method named_value_init
*
* 初始化。
* @annotation ["constructor"]
*
* @param {named_value_t*} nv named_value对象。
* @param {const char*} name 名称。
* @param {const value_t*} value 值。
*
* @return {named_value_t*} 返回named_value对象。
*/
named_value_t* named_value_init(named_value_t* nv, const char* name, const value_t* value);
/**
* @method named_value_cast
*
* 转换为named_value对象(供脚本语言使用)。
* @annotation ["cast", "scriptable"]
*
* @param {named_value_t*} nv named_value对象。
*
* @return {named_value_t*} 返回named_value对象。
*/
named_value_t* named_value_cast(named_value_t* nv);
/**
* @method named_value_set_name
*
* 设置名称。
* @annotation ["scriptable"]
*
* @param {named_value_t*} nv named_value对象。
* @param {const char*} name 名称。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_set_name(named_value_t* nv, const char* name);
/**
* @method named_value_set_value
*
* 设置值。
* @annotation ["scriptable"]
*
* @param {named_value_t*} nv named_value对象。
* @param {const value_t*} value 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_set_value(named_value_t* nv, const value_t* value);
/**
* @method named_value_get_value
*
* 获取值对象(主要给脚本语言使用)。
* @annotation ["scriptable"]
*
* @param {named_value_t*} nv named_value对象。
*
* @return {value_t*} 返回值对象。
*
*/
value_t* named_value_get_value(named_value_t* nv);
/**
* @method named_value_deinit
*
* 重置named_value对象。
* @annotation ["deconstructor"]
*
* @param {named_value_t*} nv named_value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_deinit(named_value_t* nv);
/**
* @method named_value_compare
*
* 比较。
*
* @param {named_value_t*} nv named_value对象。
* @param {const named_value_t*} other named_value对象。
*
* @return {int32_t} 返回RET_OK表示成功，否则表示失败。
*/
int32_t named_value_compare(named_value_t* nv, const named_value_t* other);
/**
* @method named_value_compare_by_name
*
* 比较。
*
* @param {named_value_t*} nv named_value对象。
* @param {const char*} name 名称。
*
* @return {int32_t} 返回RET_OK表示成功，否则表示失败。
*/
int32_t named_value_compare_by_name(named_value_t* nv, const char* name);
/**
* @method named_value_icompare
*
* 大小写不敏感比较。
*
* @param {named_value_t*} nv named_value对象。
* @param {const named_value_t*} other named_value对象。
*
* @return {int32_t} 返回RET_OK表示成功，否则表示失败。
*/
int32_t named_value_icompare(named_value_t* nv, const named_value_t* other);
/**
* @method named_value_icompare_by_name
*
* 大小写不敏感比较。
*
* @param {named_value_t*} nv named_value对象。
* @param {const char*} name 名称。
*
* @return {int32_t} 返回RET_OK表示成功，否则表示失败。
*/
int32_t named_value_icompare_by_name(named_value_t* nv, const char* name);
/**
* @method named_value_destroy
*
* 销毁named_value对象。
* @annotation ["deconstructor", "scriptable", "gc"]
*
* @param {named_value_t*} nv named_value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t named_value_destroy(named_value_t* nv);
END_C_DECLS
#endif /*TK_NAMED_VALUE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/plugin_manager.c
|
/**
* File: plugin_manager.c
* Author: AWTK Develop Team
* Brief: plugin manager
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-10-12 Li XianJing <[email protected]> created
*
*/
#include "tkc/fs.h"
#include "tkc/mem.h"
#include "tkc/path.h"
#include "tkc/utils.h"
#include "tkc/darray.h"
#include "tkc/plugin_manager.h"
typedef ret_t (*plugin_init_func_t)(void);
typedef ret_t (*plugin_deinit_func_t)(void);
typedef struct _plugin_t {
char* lib_name;
tk_dl_t* handle;
plugin_manager_t* plugin_manager;
} plugin_t;
static const char* name_from_lib_name(char name[MAX_PATH + 1], const char* lib_name) {
const char* start = lib_name + strlen(TK_DLL_PRE_NAME);
const char* end = strstr(lib_name, TK_DLL_EXT_NAME);
return_value_if_fail(end != NULL, NULL);
tk_strncpy(name, start, tk_min(MAX_PATH, end - start));
return name;
}
static ret_t plugin_destroy(plugin_t* plugin) {
return_value_if_fail(plugin != NULL, RET_BAD_PARAMS);
if (plugin->plugin_manager != NULL && plugin->handle != NULL) {
char name[MAX_PATH + 1];
char func[TK_FUNC_NAME_LEN + 1];
tk_dl_t* handle = plugin->handle;
const char* lib_name = plugin->lib_name;
plugin_manager_t* plugin_manager = plugin->plugin_manager;
memset(func, 0x00, sizeof(func));
memset(name, 0x00, sizeof(name));
if (plugin_manager->get_deinit != NULL &&
plugin_manager->get_deinit(func, name_from_lib_name(name, lib_name)) == RET_OK) {
log_debug("deinit func:%s\n", func);
} else {
tk_strncpy(func, TK_PLUGIN_DEINIT, TK_FUNC_NAME_LEN);
}
plugin_deinit_func_t deinit = (plugin_deinit_func_t)tk_dl_sym(handle, func);
if (deinit != NULL) {
ret_t ret = deinit();
log_debug("%s: deinit %d\n", lib_name, ret);
} else {
log_debug("%s: no deinit func\n", lib_name);
}
}
TKMEM_FREE(plugin->lib_name);
if (plugin->handle != NULL) {
tk_dl_close(plugin->handle);
plugin->handle = NULL;
}
TKMEM_FREE(plugin);
return RET_OK;
}
static plugin_t* plugin_create(const char* path, const char* lib_name,
plugin_manager_t* plugin_manager) {
tk_dl_t* handle = NULL;
plugin_t* plugin = NULL;
char filename[MAX_PATH + 1];
memset(filename, 0x00, sizeof(filename));
return_value_if_fail(lib_name != NULL && path != NULL, NULL);
path_build(filename, MAX_PATH, path, lib_name, NULL);
handle = tk_dl_open(filename);
if (handle == NULL) {
log_debug("dlopen %s failed: %s\n", filename, tk_dl_error());
}
return_value_if_fail(handle != NULL, NULL);
plugin = TKMEM_ZALLOC(plugin_t);
if (plugin != NULL) {
plugin->handle = handle;
plugin->plugin_manager = plugin_manager;
plugin->lib_name = tk_strdup(lib_name);
if (plugin->lib_name == NULL) {
plugin_destroy(plugin);
plugin = NULL;
}
} else {
tk_dl_close(handle);
}
if (plugin != NULL) {
char name[MAX_PATH + 1];
char func[TK_FUNC_NAME_LEN + 1];
memset(name, 0x00, sizeof(name));
memset(func, 0x00, sizeof(func));
if (plugin_manager->get_init != NULL &&
plugin_manager->get_init(func, name_from_lib_name(name, lib_name)) == RET_OK) {
log_debug("init func:%s\n", func);
} else {
tk_strncpy(func, TK_PLUGIN_INIT, TK_FUNC_NAME_LEN);
}
plugin_init_func_t init = (plugin_init_func_t)tk_dl_sym(handle, func);
if (init != NULL) {
ret_t ret = init();
log_debug("%s: init %d\n", lib_name, ret);
} else {
log_debug("%s: no init func\n", lib_name);
}
}
return plugin;
}
static int32_t plugin_compare(plugin_t* plugin, const char* lib_name) {
return strcmp(plugin->lib_name, lib_name);
}
plugin_manager_t* plugin_manager_create(const char* path, plugin_get_init_func_name_t get_init,
plugin_get_deinit_func_name_t get_deinit) {
plugin_manager_t* plugin_manager = NULL;
return_value_if_fail(path != NULL && path_exist(path), NULL);
plugin_manager = TKMEM_ZALLOC(plugin_manager_t);
return_value_if_fail(plugin_manager != NULL, NULL);
plugin_manager->path = tk_strdup(path);
plugin_manager->get_init = get_init;
plugin_manager->get_deinit = get_deinit;
ENSURE(plugin_manager->path != NULL);
darray_init(&(plugin_manager->plugins), 5, (tk_destroy_t)plugin_destroy,
(tk_compare_t)plugin_compare);
plugin_manager_reload(plugin_manager);
return plugin_manager;
}
static ret_t plugin_manager_unload(plugin_manager_t* plugin_manager) {
return_value_if_fail(plugin_manager != NULL, RET_BAD_PARAMS);
darray_clear(&(plugin_manager->plugins));
return RET_OK;
}
bool_t plugin_manager_exist(plugin_manager_t* plugin_manager, const char* lib_name) {
return darray_find(&(plugin_manager->plugins), (void*)lib_name) != NULL;
}
ret_t plugin_manager_refresh(plugin_manager_t* plugin_manager) {
fs_item_t item;
fs_dir_t* dir = NULL;
return_value_if_fail(plugin_manager != NULL, RET_BAD_PARAMS);
dir = fs_open_dir(os_fs(), plugin_manager->path);
return_value_if_fail(dir != NULL, RET_BAD_PARAMS);
memset(&item, 0x00, sizeof(item));
while (fs_dir_read(dir, &item) == RET_OK) {
if (!item.is_reg_file) {
continue;
}
if (strstr(item.name, TK_DLL_EXT_NAME) != NULL) {
if (!plugin_manager_exist(plugin_manager, item.name)) {
plugin_t* plugin = plugin_create(plugin_manager->path, item.name, plugin_manager);
if (plugin != NULL) {
if (darray_push(&(plugin_manager->plugins), plugin) != RET_OK) {
plugin_destroy(plugin);
return RET_OOM;
}
}
} else {
log_debug("%s exist\n", item.name);
}
} else {
log_debug("skip %s\n", item.name);
}
}
fs_dir_close(dir);
return RET_OK;
}
ret_t plugin_manager_reload(plugin_manager_t* plugin_manager) {
return_value_if_fail(plugin_manager != NULL, RET_BAD_PARAMS);
plugin_manager_unload(plugin_manager);
return plugin_manager_refresh(plugin_manager);
}
ret_t plugin_manager_dump(plugin_manager_t* plugin_manager) {
uint32_t i = 0;
return_value_if_fail(plugin_manager != NULL, RET_BAD_PARAMS);
for (i = 0; i < plugin_manager->plugins.size; i++) {
plugin_t* iter = (plugin_t*)(plugin_manager->plugins.elms[i]);
log_debug("%u: %s %p\n", i, iter->lib_name, iter->handle);
(void)iter;
}
return RET_OK;
}
ret_t plugin_manager_destroy(plugin_manager_t* plugin_manager) {
return_value_if_fail(plugin_manager != NULL, RET_BAD_PARAMS);
plugin_manager_unload(plugin_manager);
TKMEM_FREE(plugin_manager->path);
darray_deinit(&(plugin_manager->plugins));
TKMEM_FREE(plugin_manager);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/easing.h
|
/**
* File: easing.h
* Author: AWTK Develop Team
* Brief: easing functions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-04-18 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EASING_H
#define TK_EASING_H
#include "tkc/darray.h"
#include "tkc/types_def.h"
BEGIN_C_DECLS
typedef float_t (*easing_func_t)(float_t k);
typedef struct _easing_name_func_t {
key_type_value_t* type_name_value;
easing_func_t easing_func;
} easing_name_func_t;
/**
* @enum easing_type_t
* @prefix EASING_
* @annotation ["scriptable"]
* 缓动作动画常量定义。
*/
typedef enum _easing_type_t {
/**
* @const EASING_LINEAR
* EASING_LINEAR。
*/
EASING_LINEAR = 0,
/**
* @const EASING_QUADRATIC_IN
* EASING_QUADRATIC_IN
*/
EASING_QUADRATIC_IN,
/**
* @const EASING_QUADRATIC_OUT
* EASING_QUADRATIC_OUT
*/
EASING_QUADRATIC_OUT,
/**
* @const EASING_QUADRATIC_INOUT
* EASING_QUADRATIC_INOUT
*/
EASING_QUADRATIC_INOUT,
/**
* @const EASING_CUBIC_IN
* EASING_CUBIC_IN
*/
EASING_CUBIC_IN,
/**
* @const EASING_CUBIC_OUT
* EASING_CUBIC_OUT
*/
EASING_CUBIC_OUT,
/**
* @const EASING_SIN_IN
* EASING_SIN_IN
*/
EASING_SIN_IN,
/**
* @const EASING_SIN_OUT
* EASING_SIN_OUT
*/
EASING_SIN_OUT,
/**
* @const EASING_SIN_INOUT
* EASING_SIN_OUT
*/
EASING_SIN_INOUT,
/**
* @const EASING_POW_IN
* EASING_POW_IN
*/
EASING_POW_IN,
/**
* @const EASING_POW_OUT
* EASING_POW_OUT
*/
EASING_POW_OUT,
/**
* @const EASING_POW_INOUT
* EASING_POW_INOUT
*/
EASING_POW_INOUT,
/**
* @const EASING_CIRCULAR_IN
* EASING_CIRCULAR_IN
*/
EASING_CIRCULAR_IN,
/**
* @const EASING_CIRCULAR_OUT
* EASING_CIRCULAR_OUT
*/
EASING_CIRCULAR_OUT,
/**
* @const EASING_CIRCULAR_INOUT
* EASING_CIRCULAR_INOUT
*/
EASING_CIRCULAR_INOUT,
/**
* @const EASING_ELASTIC_IN
* EASING_ELASTIC_IN
*/
EASING_ELASTIC_IN,
/**
* @const EASING_ELASTIC_OUT
* EASING_ELASTIC_OUT
*/
EASING_ELASTIC_OUT,
/**
* @const EASING_ELASTIC_INOUT
* EASING_ELASTIC_INOUT
*/
EASING_ELASTIC_INOUT,
/**
* @const EASING_BACK_IN
* EASING_BACK_IN
*/
EASING_BACK_IN,
/**
* @const EASING_BACK_OUT
* EASING_BACK_OUT
*/
EASING_BACK_OUT,
/**
* @const EASING_BACK_INOUT
* EASING_BACK_INOUT
*/
EASING_BACK_INOUT,
/**
* @const EASING_BOUNCE_IN
* EASING_BOUNCE_IN
*/
EASING_BOUNCE_IN,
/**
* @const EASING_BOUNCE_OUT
* EASING_BOUNCE_OUT
*/
EASING_BOUNCE_OUT,
/**
* @const EASING_BOUNCE_INOUT
* EASING_BOUNCE_INOUT
*/
EASING_BOUNCE_INOUT,
EASING_FUNC_NR
} easing_type_t;
/**
* @class easing_t
* @annotation ["fake"]
* 动画趋势类。
*
*/
/**
* @method easing_get
* 获取对应类型的操作函数。
* @param {easing_type_t} type 类型。
*
* @return {easing_func_t} 返回对应的操作函数地址。
*/
easing_func_t easing_get(easing_type_t type);
/**
* @method easing_register
* 注册指定名称的动画趋势。
* @param {const char*} type_name 类型名称。
* @param {easing_func_t} easing_func 动画趋势函数。
*
* @return {uint32_t} 返回对应类型。
*/
uint32_t easing_register(const char* type_name, easing_func_t easing_func);
/*public for awtk only*/
ret_t easing_init(void);
ret_t easing_deinit(void);
darray_t* easing_name_func_darray(void);
END_C_DECLS
#endif /*TK_EASING_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/asset_info.c
|
/**
* File: asset_info.c
* Author: AWTK Develop Team
* Brief: asset info
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-03-07 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/utils.h"
#include "tkc/asset_info.h"
static ret_t asset_info_set_full_name_flag(asset_info_t* info);
static bool_t asset_info_is_full_name(const asset_info_t* info);
const char* asset_info_get_formatted_name(const char* name) {
uint32_t len = 0;
return_value_if_fail(name != NULL, NULL);
len = tk_strlen(name);
if (len < TK_NAME_LEN) {
return name;
} else {
uint32_t p = len - TK_NAME_LEN;
return name + p;
}
}
asset_info_t* asset_info_create(uint16_t type, uint16_t subtype, const char* name, int32_t size) {
asset_info_t* info = NULL;
uint32_t total = sizeof(asset_info_t) + size + 1;
return_value_if_fail(name != NULL, NULL);
info = TKMEM_ALLOC(total);
return_value_if_fail(info != NULL, NULL);
memset(info, 0x00, total);
info->size = size;
info->type = type;
info->subtype = subtype;
info->refcount = 1;
asset_info_set_is_in_rom(info, FALSE);
asset_info_set_name(info, name, TRUE);
#ifdef LOAD_ASSET_WITH_MMAP
if (size > 0) {
info->data = TKMEM_ALLOC(size + 1);
if (info->data != NULL) {
memset(info->data, 0x00, size + 1);
} else {
TKMEM_FREE(info);
return NULL;
}
}
#endif /*LOAD_ASSET_WITH_MMAP*/
return info;
}
ret_t asset_info_destroy(asset_info_t* info) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
if (!asset_info_is_in_rom(info)) {
#ifdef LOAD_ASSET_WITH_MMAP
if (info->map != NULL) {
mmap_destroy(info->map);
} else if (info->data != NULL) {
TKMEM_FREE(info->data);
}
#endif /*LOAD_ASSET_WITH_MMAP*/
if (asset_info_is_full_name(info)) {
TKMEM_FREE(info->name.full_name);
}
memset(info, 0x00, sizeof(asset_info_t));
TKMEM_FREE(info);
}
return RET_OK;
}
ret_t asset_info_unref(asset_info_t* info) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
if (!asset_info_is_in_rom(info)) {
if (info->refcount > 0) {
info->refcount--;
if (info->refcount == 0) {
asset_info_destroy(info);
}
}
}
return RET_OK;
}
ret_t asset_info_ref(asset_info_t* info) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
if (!asset_info_is_in_rom(info)) {
info->refcount++;
}
return RET_OK;
}
uint16_t asset_info_get_type(asset_info_t* info) {
return_value_if_fail(info != NULL, ASSET_TYPE_NONE);
return info->type;
}
const char* asset_info_get_name(const asset_info_t* info) {
return_value_if_fail(info != NULL, NULL);
if (asset_info_is_full_name(info)) {
return info->name.full_name;
} else {
return info->name.small_name;
}
}
bool_t asset_info_is_in_rom(const asset_info_t* info) {
return_value_if_fail(info != NULL, FALSE);
return info->flags & ASSET_INFO_FLAG_IN_ROM;
}
ret_t asset_info_set_is_in_rom(asset_info_t* info, bool_t is_in_rom) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
if (is_in_rom) {
info->flags |= ASSET_INFO_FLAG_IN_ROM;
} else {
info->flags &= ~ASSET_INFO_FLAG_IN_ROM;
}
return RET_OK;
}
static ret_t asset_info_set_full_name_flag(asset_info_t* info) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
info->flags |= ASSET_INFO_FLAG_FULL_NAME;
return RET_OK;
}
static bool_t asset_info_is_full_name(const asset_info_t* info) {
return_value_if_fail(info != NULL, RET_BAD_PARAMS);
return info->flags & ASSET_INFO_FLAG_FULL_NAME;
}
ret_t asset_info_set_name(asset_info_t* info, const char* name, bool_t is_alloc) {
uint32_t len = 0;
return_value_if_fail(info != NULL && name != NULL, RET_BAD_PARAMS);
len = tk_strlen(name);
if (len <= TK_NAME_LEN) {
memset(info->name.small_name, 0x0, sizeof(info->name.small_name));
tk_memcpy(info->name.small_name, name, len);
} else {
if (is_alloc) {
info->name.full_name = tk_strdup(name);
} else {
info->name.full_name = (char*)name;
}
asset_info_set_full_name_flag(info);
}
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/waitable_ring_buffer.c
|
/**
* File: waitable_ring_buffer.c
* Author: AWTK Develop Team
* Brief: waitable_ring_buffer
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-04-02 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/waitable_ring_buffer.h"
waitable_ring_buffer_t* waitable_ring_buffer_create(uint32_t capacity, uint32_t block_size) {
waitable_ring_buffer_t* rb = TKMEM_ZALLOC(waitable_ring_buffer_t);
return_value_if_fail(rb != NULL, NULL);
rb->ring_buffer = ring_buffer_create(capacity * block_size, capacity * block_size);
goto_error_if_fail(rb->ring_buffer != NULL);
rb->block_size = block_size;
rb->mutex = tk_mutex_create();
goto_error_if_fail(rb->mutex != NULL);
rb->sema_read = tk_semaphore_create(0, NULL);
goto_error_if_fail(rb->sema_read != NULL);
rb->sema_write = tk_semaphore_create(capacity, NULL);
goto_error_if_fail(rb->sema_write != NULL);
return rb;
error:
if (rb != NULL) {
if (rb->ring_buffer != NULL) {
ring_buffer_destroy(rb->ring_buffer);
}
if (rb->mutex != NULL) {
tk_mutex_destroy(rb->mutex);
}
if (rb->sema_read != NULL) {
tk_semaphore_destroy(rb->sema_read);
}
if (rb->sema_write != NULL) {
tk_semaphore_destroy(rb->sema_write);
}
TKMEM_FREE(rb);
}
return NULL;
}
ret_t waitable_ring_buffer_read(waitable_ring_buffer_t* rb, void* buff, uint32_t size,
uint32_t timeout_ms) {
ret_t ret = RET_FAIL;
return_value_if_fail(rb != NULL && buff != NULL, RET_BAD_PARAMS);
return_value_if_fail(size == rb->block_size, RET_BAD_PARAMS);
if (tk_semaphore_wait(rb->sema_read, timeout_ms) == RET_OK) {
if (tk_mutex_lock(rb->mutex) == RET_OK) {
ret = ring_buffer_read_len(rb->ring_buffer, buff, size);
if (ret == RET_OK) {
ENSURE(tk_semaphore_post(rb->sema_write) == RET_OK);
}
ENSURE(tk_mutex_unlock(rb->mutex) == RET_OK);
}
}
return ret;
}
ret_t waitable_ring_buffer_write(waitable_ring_buffer_t* rb, const void* buff, uint32_t size,
uint32_t timeout_ms) {
ret_t ret = RET_FAIL;
return_value_if_fail(rb != NULL && buff != NULL, RET_BAD_PARAMS);
return_value_if_fail(size == rb->block_size, RET_BAD_PARAMS);
if (tk_semaphore_wait(rb->sema_write, timeout_ms) == RET_OK) {
if (tk_mutex_lock(rb->mutex) == RET_OK) {
ret = ring_buffer_write_len(rb->ring_buffer, buff, size);
assert(ret == RET_OK);
ENSURE(tk_semaphore_post(rb->sema_read) == RET_OK);
ENSURE(tk_mutex_unlock(rb->mutex) == RET_OK);
}
}
return ret;
}
ret_t waitable_ring_buffer_destroy(waitable_ring_buffer_t* rb) {
return_value_if_fail(rb != NULL, RET_BAD_PARAMS);
ENSURE(ring_buffer_destroy(rb->ring_buffer) == RET_OK);
ENSURE(tk_mutex_destroy(rb->mutex) == RET_OK);
ENSURE(tk_semaphore_destroy(rb->sema_read) == RET_OK);
ENSURE(tk_semaphore_destroy(rb->sema_write) == RET_OK);
TKMEM_FREE(rb);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_rbuffer.c
|
/**
* File: object_rbuffer.c
* Author: AWTK Develop Team
* Brief: wrap rbuffer to an object.
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2021-01-03 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "object_rbuffer.h"
static ret_t object_rbuffer_on_destroy(tk_object_t* obj) {
return RET_OK;
}
static ret_t object_rbuffer_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
return RET_NOT_FOUND;
}
static ret_t object_rbuffer_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_rbuffer_t* o = OBJECT_RBUFFER(obj);
return_value_if_fail(o != NULL && o->rbuffer != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, "cursor")) {
value_set_uint32(v, o->rbuffer->cursor);
ret = RET_OK;
} else if (tk_str_eq(name, "capacity")) {
value_set_uint32(v, o->rbuffer->capacity);
ret = RET_OK;
} else if (tk_str_eq(name, "data")) {
value_set_pointer(v, (void*)(o->rbuffer->data));
ret = RET_OK;
}
return ret;
}
static const object_vtable_t s_object_rbuffer_vtable = {.type = OBJECT_RBUFFER_TYPE,
.desc = OBJECT_RBUFFER_TYPE,
.size = sizeof(object_rbuffer_t),
.is_collection = FALSE,
.on_destroy = object_rbuffer_on_destroy,
.get_prop = object_rbuffer_get_prop,
.set_prop = object_rbuffer_set_prop};
tk_object_t* object_rbuffer_create(const uint8_t* data, uint32_t capacity) {
tk_object_t* o = NULL;
object_rbuffer_t* wrapper = NULL;
o = tk_object_create(&s_object_rbuffer_vtable);
return_value_if_fail(o != NULL, NULL);
wrapper = OBJECT_RBUFFER(o);
return_value_if_fail(wrapper != NULL, NULL);
wrapper->rbuffer = rbuffer_init(&(wrapper->arbuffer), data, capacity);
return o;
}
object_rbuffer_t* object_rbuffer_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_rbuffer_vtable, NULL);
return (object_rbuffer_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/path.c
|
/**
* File: path.c
* Author: AWTK Develop Team
* Brief: path
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-08-26 Li XianJing <[email protected]> created
*
*/
#include <stdarg.h>
#include "tkc/fs.h"
#include "tkc/path.h"
#include "tkc/utils.h"
#define IS_PATH_SEP(c) ((c) == '/' || (c) == '\\')
ret_t path_basename_ex(const char* path, bool_t remove_ext_name, char* result, int32_t size) {
const char *p = NULL, *p2 = NULL;
int32_t real_size = 0;
return_value_if_fail(path != NULL && result != NULL, RET_BAD_PARAMS);
memset(result, 0x00, size);
p = strrchr(path, '/');
p2 = strrchr(path, '\\');
p = tk_max(p, p2);
if (p == NULL) {
p = path;
} else {
p++;
}
real_size = strlen(p);
return_value_if_fail(real_size < size, RET_BAD_PARAMS);
tk_strncpy(result, p, size - 1);
if (remove_ext_name) {
char* ext = strrchr(result, '.');
if (ext != NULL) {
*ext = '\0';
}
}
return RET_OK;
}
ret_t path_basename(const char* path, char* result, int32_t size) {
return path_basename_ex(path, FALSE, result, size);
}
ret_t path_extname(const char* path, char* result, int32_t size) {
const char* p = NULL;
int32_t real_size = 0;
return_value_if_fail(path != NULL && result != NULL, RET_BAD_PARAMS);
memset(result, 0x00, size);
p = strrchr(path, '.');
if (p != NULL) {
real_size = strlen(p);
return_value_if_fail(real_size < size, RET_BAD_PARAMS);
tk_strncpy(result, p, size - 1);
return RET_OK;
}
return RET_FAIL;
}
ret_t path_dirname(const char* path, char* result, int32_t size) {
const char* p = NULL;
const char* p1 = NULL;
int32_t real_size = 0;
return_value_if_fail(path != NULL && result != NULL, RET_BAD_PARAMS);
memset(result, 0x00, size);
p = strrchr(path, '\\');
p1 = strrchr(path, '/');
if (p == NULL && p1 != NULL) {
p = p1;
} else if (p != NULL && p1 != NULL) {
if (p - p1 < 0) {
p = p1;
}
}
if (p != NULL) {
real_size = p - path + 1;
return_value_if_fail(real_size < size, RET_BAD_PARAMS);
tk_strncpy(result, path, real_size);
return RET_OK;
}
return RET_FAIL;
}
bool_t path_exist(const char* path) {
return fs_dir_exist(os_fs(), path);
}
ret_t path_cwd(char path[MAX_PATH + 1]) {
return fs_get_cwd(os_fs(), path);
}
ret_t path_exe(char path[MAX_PATH + 1]) {
return fs_get_exe(os_fs(), path);
}
ret_t path_app_root(char path[MAX_PATH + 1]) {
char* p = NULL;
char exe_path[MAX_PATH + 1];
memset(exe_path, 0x00, sizeof(exe_path));
if (fs_get_exe(os_fs(), exe_path) == RET_OK) {
path_normalize(exe_path, path, MAX_PATH + 1);
p = strrchr(path, TK_PATH_SEP);
if (p != NULL) {
*p = '\0';
p = strrchr(path, TK_PATH_SEP);
if (p != NULL) {
if (strcmp(p + 1, "bin") == 0) {
*p = '\0';
}
}
return RET_OK;
}
}
return RET_FAIL;
}
static char* path_up(char* path, uint32_t size) {
uint32_t len = tk_min(strlen(path), size);
if (len > 0) {
char* p = path + strlen(path) - 1;
if (IS_PATH_SEP(*p)) {
*p = '\0';
p--;
}
while (p > path && *p != '/' && *p != '\\') {
p--;
}
if (path == p) {
if (*p != '/' && *p != '\\') {
p[0] = '\0';
return p;
} else {
p[0] = TK_PATH_SEP;
}
} else {
p[0] = TK_PATH_SEP;
}
memset(p + 1, 0x0, size - (p - path) - 1);
return p + 1;
} else {
return path;
}
}
ret_t path_normalize(const char* path, char* result, int32_t size) {
const char* s = path;
char* d = result;
return_value_if_fail(path != NULL && result != NULL, RET_BAD_PARAMS);
memset(result, 0x00, size);
while ((d - result) < size && *s) {
switch (*s) {
case '/':
case '\\': {
if (s[1] == '.' && s[2] == '\0') {
s += 2;
break;
}
if (d == result || !IS_PATH_SEP(d[-1])) {
*d++ = TK_PATH_SEP;
}
while (IS_PATH_SEP(*s)) {
s++;
}
break;
}
case '.': {
if (IS_PATH_SEP(s[1])) {
s += 2;
} else if (s[1] == '.') {
return_value_if_fail(IS_PATH_SEP(s[2]) || s[2] == '\0', RET_FAIL);
d = path_up(result, size);
s += 2;
if (IS_PATH_SEP(s[0])) {
s++;
}
} else {
*d++ = *s++;
}
break;
}
default: {
*d++ = *s++;
}
}
}
return RET_OK;
}
bool_t path_is_abs(const char* path) {
return_value_if_fail(path != NULL && *path, FALSE);
return path[0] == '/' || path[1] == ':';
}
ret_t path_abs(const char* path, char* result, int32_t size) {
char cwd[MAX_PATH + 1];
return_value_if_fail(path != NULL && result != NULL && strlen(path) < size, RET_BAD_PARAMS);
if (path_is_abs(path)) {
tk_strncpy(result, path, size);
return RET_OK;
}
if (path_cwd(cwd) == RET_OK) {
return path_build(result, size, cwd, path, NULL);
}
return RET_FAIL;
}
ret_t path_build(char* result, int32_t size, ...) {
va_list va;
char* d = result;
const char* p = NULL;
int32_t avail_size = size;
return_value_if_fail(result != NULL, RET_BAD_PARAMS);
memset(result, 0x00, size);
va_start(va, size);
do {
p = va_arg(va, char*);
if (p != NULL) {
int32_t new_size = strlen(p);
return_value_if_fail(((new_size + 1) < avail_size), RET_FAIL);
if (d != result) {
if (d[-1] != TK_PATH_SEP) {
*d++ = TK_PATH_SEP;
}
}
memcpy(d, p, new_size);
avail_size -= new_size;
d += new_size;
} else {
break;
}
} while (p != NULL);
va_end(va);
return RET_OK;
}
ret_t path_replace_basename(char* result, int32_t size, const char* filename,
const char* basename) {
char dirname[MAX_PATH + 1];
return_value_if_fail(result != NULL && filename != NULL && basename != NULL, RET_BAD_PARAMS);
path_normalize(filename, result, size);
path_dirname(result, dirname, MAX_PATH);
dirname[MAX_PATH] = '\0';
return path_build(result, size, dirname, basename, NULL);
}
ret_t path_replace_extname(char* result, int32_t size, const char* filename, const char* extname) {
char* p = NULL;
return_value_if_fail(result != NULL && filename != NULL && extname != NULL, RET_BAD_PARAMS);
memset(result, 0x00, size);
path_normalize(filename, result, size);
p = strrchr(result, '.');
if (p != NULL) {
uint32_t n = 0;
p++;
*p = '\0';
n = size - strlen(result) - 1;
strncpy(p, extname, n);
}
return RET_OK;
}
ret_t path_remove_last_slash(char* path) {
char* p = NULL;
return_value_if_fail(path != NULL, RET_BAD_PARAMS);
p = path + strlen(path) - 1;
while (p > path) {
if (*p == '/' || *p == '\\') {
*p = '\0';
p--;
} else {
break;
}
}
return RET_OK;
}
bool_t path_extname_is(const char* path, const char* extname) {
const char* p = NULL;
return_value_if_fail(path != NULL && extname != NULL, FALSE);
p = strrchr(path, '.');
return (p != NULL && tk_str_ieq(p, extname));
}
ret_t path_app_root_ex(char path[MAX_PATH + 1], const char* subpath) {
char app_root[MAX_PATH + 1] = {0};
return_value_if_fail(path_app_root(app_root) == RET_OK, RET_BAD_PARAMS);
path_build(path, MAX_PATH, app_root, subpath, NULL);
return RET_OK;
}
const char* path_prepend_app_root(char full_path[MAX_PATH + 1], const char* path) {
char app_root[MAX_PATH + 1] = {0};
return_value_if_fail(path != NULL, NULL);
return_value_if_fail(path_app_root(app_root) == RET_OK, NULL);
path_build(full_path, MAX_PATH, app_root, path, NULL);
return full_path;
}
const char* path_prepend_temp_path(char full_path[MAX_PATH + 1], const char* path) {
char temp_path[MAX_PATH + 1] = {0};
return_value_if_fail(path != NULL, NULL);
return_value_if_fail(fs_get_temp_path(os_fs(), temp_path) == RET_OK, NULL);
path_build(full_path, MAX_PATH, temp_path, path, NULL);
return full_path;
}
const char* path_prepend_user_storage_path(char full_path[MAX_PATH + 1], const char* path) {
char user_storage_path[MAX_PATH + 1] = {0};
return_value_if_fail(path != NULL, NULL);
return_value_if_fail(fs_get_user_storage_path(os_fs(), user_storage_path) == RET_OK, NULL);
path_build(full_path, MAX_PATH, user_storage_path, path, NULL);
return full_path;
}
ret_t path_abs_normalize(const char* filename, char* result, int32_t size) {
char path[MAX_PATH + 1];
return_value_if_fail(filename != NULL && result != NULL && size > 0, RET_BAD_PARAMS);
path_abs(filename, path, MAX_PATH);
return path_normalize(path, result, size);
}
const char* path_abs_normalize_with_root(const char* root, const char* rel_filename,
char filename[MAX_PATH + 1]) {
char path[MAX_PATH + 1];
char abs_root[MAX_PATH + 1];
return_value_if_fail(root != NULL && rel_filename != NULL, NULL);
path_abs_normalize(root, abs_root, MAX_PATH);
path_build(path, MAX_PATH, abs_root, rel_filename, NULL);
path_normalize(path, filename, MAX_PATH);
if (strncmp(filename, abs_root, strlen(abs_root)) == 0) {
return filename;
} else {
return NULL;
}
}
ret_t path_expand_vars(const char* filename, char* result, int32_t size) {
str_t str;
char path[MAX_PATH + 1] = {0};
return_value_if_fail(filename != NULL && result != NULL && size > 0, RET_BAD_PARAMS);
str_init(&str, MAX_PATH + 1);
str_set(&str, filename);
fs_get_user_storage_path(os_fs(), path);
str_replace(&str, "${user_dir}", path);
fs_get_temp_path(os_fs(), path);
str_replace(&str, "${temp_dir}", path);
path_app_root(path);
str_replace(&str, "${app_dir}", path);
tk_strncpy_s(result, size, str.str, str.size);
str_reset(&str);
return RET_OK;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mime_types.h
|
/**
* File: types_def.h
* Author: AWTK Develop Team
* Brief: basic types definitions.
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-28 Li XianJing <[email protected]> created
*
*/
#ifndef MIME_TYPES_H
#define MIME_TYPES_H
/**
* @enum MIME_TYPE
* @annotation ["scriptable", "string"]
* @prefix MIME_TYPE_
* MIME_TYPE。
*/
/**
* @const MIME_TYPE_APPLICATION_ENVOY
* "application/envoy"。
*/
#define MIME_TYPE_APPLICATION_ENVOY "application/envoy"
/**
* @const MIME_TYPE_APPLICATION_FRACTALS
* "application/fractals"。
*/
#define MIME_TYPE_APPLICATION_FRACTALS "application/fractals"
/**
* @const MIME_TYPE_APPLICATION_FUTURESPLASH
* "application/futuresplash"。
*/
#define MIME_TYPE_APPLICATION_FUTURESPLASH "application/futuresplash"
/**
* @const MIME_TYPE_APPLICATION_HTA
* "application/hta"。
*/
#define MIME_TYPE_APPLICATION_HTA "application/hta"
/**
* @const MIME_TYPE_APPLICATION_JSON
* "application/json"。
*/
#define MIME_TYPE_APPLICATION_JSON "application/json"
/**
* @const MIME_TYPE_APPLICATION_UBJSON
* "application/ubjson"。
*/
#define MIME_TYPE_APPLICATION_UBJSON "application/ubjson"
/**
* @const MIME_TYPE_APPLICATION_MAC_BINHEX40
* "application/mac-binhex40"。
*/
#define MIME_TYPE_APPLICATION_MAC_BINHEX40 "application/mac-binhex40"
/**
* @const MIME_TYPE_APPLICATION_MSWORD
* "application/msword"。
*/
#define MIME_TYPE_APPLICATION_MSWORD "application/msword"
/**
* @const MIME_TYPE_APPLICATION_OCTET_STREAM
* "application/octet-stream"。
*/
#define MIME_TYPE_APPLICATION_OCTET_STREAM "application/octet-stream"
/**
* @const MIME_TYPE_APPLICATION_ODA
* "application/oda"。
*/
#define MIME_TYPE_APPLICATION_ODA "application/oda"
/**
* @const MIME_TYPE_APPLICATION_OLESCRIPT
* "application/olescript"。
*/
#define MIME_TYPE_APPLICATION_OLESCRIPT "application/olescript"
/**
* @const MIME_TYPE_APPLICATION_PDF
* "application/pdf"。
*/
#define MIME_TYPE_APPLICATION_PDF "application/pdf"
/**
* @const MIME_TYPE_APPLICATION_PICS_RULES
* "application/pics-rules"。
*/
#define MIME_TYPE_APPLICATION_PICS_RULES "application/pics-rules"
/**
* @const MIME_TYPE_APPLICATION_PKCS10
* "application/pkcs10"。
*/
#define MIME_TYPE_APPLICATION_PKCS10 "application/pkcs10"
/**
* @const MIME_TYPE_APPLICATION_PKIX_CRL
* "application/pkix-crl"。
*/
#define MIME_TYPE_APPLICATION_PKIX_CRL "application/pkix-crl"
/**
* @const MIME_TYPE_APPLICATION_POSTSCRIPT
* "application/postscript"。
*/
#define MIME_TYPE_APPLICATION_POSTSCRIPT "application/postscript"
/**
* @const MIME_TYPE_APPLICATION_RTF
* "application/rtf"。
*/
#define MIME_TYPE_APPLICATION_RTF "application/rtf"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_EXCEL
* "application/vnd.ms-excel"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_EXCEL "application/vnd.ms-excel"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_OUTLOOK
* "application/vnd.ms-outlook"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_OUTLOOK "application/vnd.ms-outlook"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_PKICERTSTORE
* "application/vnd.ms-pkicertstore"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_PKICERTSTORE "application/vnd.ms-pkicertstore"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_PKISECCAT
* "application/vnd.ms-pkiseccat"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_PKISECCAT "application/vnd.ms-pkiseccat"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_PKISTL
* "application/vnd.ms-pkistl"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_PKISTL "application/vnd.ms-pkistl"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_POWERPOINT
* "application/vnd.ms-powerpoint"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_POWERPOINT "application/vnd.ms-powerpoint"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_PROJECT
* "application/vnd.ms-project"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_PROJECT "application/vnd.ms-project"
/**
* @const MIME_TYPE_APPLICATION_VND_MS_WORKS
* "application/vnd.ms-works"。
*/
#define MIME_TYPE_APPLICATION_VND_MS_WORKS "application/vnd.ms-works"
/**
* @const MIME_TYPE_APPLICATION_WINHLP
* "application/winhlp"。
*/
#define MIME_TYPE_APPLICATION_WINHLP "application/winhlp"
/**
* @const MIME_TYPE_APPLICATION_X_BCPIO
* "application/x-bcpio"。
*/
#define MIME_TYPE_APPLICATION_X_BCPIO "application/x-bcpio"
/**
* @const MIME_TYPE_APPLICATION_X_CDF
* "application/x-cdf"。
*/
#define MIME_TYPE_APPLICATION_X_CDF "application/x-cdf"
/**
* @const MIME_TYPE_APPLICATION_X_COMPRESS
* "application/x-compress"。
*/
#define MIME_TYPE_APPLICATION_X_COMPRESS "application/x-compress"
/**
* @const MIME_TYPE_APPLICATION_X_COMPRESSED
* "application/x-compressed"。
*/
#define MIME_TYPE_APPLICATION_X_COMPRESSED "application/x-compressed"
/**
* @const MIME_TYPE_APPLICATION_X_CPIO
* "application/x-cpio"。
*/
#define MIME_TYPE_APPLICATION_X_CPIO "application/x-cpio"
/**
* @const MIME_TYPE_APPLICATION_X_CSH
* "application/x-csh"。
*/
#define MIME_TYPE_APPLICATION_X_CSH "application/x-csh"
/**
* @const MIME_TYPE_APPLICATION_X_DIRECTOR
* "application/x-director"。
*/
#define MIME_TYPE_APPLICATION_X_DIRECTOR "application/x-director"
/**
* @const MIME_TYPE_APPLICATION_X_DVI
* "application/x-dvi"。
*/
#define MIME_TYPE_APPLICATION_X_DVI "application/x-dvi"
/**
* @const MIME_TYPE_APPLICATION_X_GTAR
* "application/x-gtar"。
*/
#define MIME_TYPE_APPLICATION_X_GTAR "application/x-gtar"
/**
* @const MIME_TYPE_APPLICATION_X_GZIP
* "application/x-gzip"。
*/
#define MIME_TYPE_APPLICATION_X_GZIP "application/x-gzip"
/**
* @const MIME_TYPE_APPLICATION_X_HDF
* "application/x-hdf"。
*/
#define MIME_TYPE_APPLICATION_X_HDF "application/x-hdf"
/**
* @const MIME_TYPE_APPLICATION_X_IPHONE
* "application/x-iphone"。
*/
#define MIME_TYPE_APPLICATION_X_IPHONE "application/x-iphone"
/**
* @const MIME_TYPE_APPLICATION_X_JAVASCRIPT
* "application/x-javascript"。
*/
#define MIME_TYPE_APPLICATION_X_JAVASCRIPT "application/x-javascript"
/**
* @const MIME_TYPE_APPLICATION_X_LATEX
* "application/x-latex"。
*/
#define MIME_TYPE_APPLICATION_X_LATEX "application/x-latex"
/**
* @const MIME_TYPE_APPLICATION_X_MSACCESS
* "application/x-msaccess"。
*/
#define MIME_TYPE_APPLICATION_X_MSACCESS "application/x-msaccess"
/**
* @const MIME_TYPE_APPLICATION_X_MSCARDFILE
* "application/x-mscardfile"。
*/
#define MIME_TYPE_APPLICATION_X_MSCARDFILE "application/x-mscardfile"
/**
* @const MIME_TYPE_APPLICATION_X_MSCLIP
* "application/x-msclip"。
*/
#define MIME_TYPE_APPLICATION_X_MSCLIP "application/x-msclip"
/**
* @const MIME_TYPE_APPLICATION_X_MSDOWNLOAD
* "application/x-msdownload"。
*/
#define MIME_TYPE_APPLICATION_X_MSDOWNLOAD "application/x-msdownload"
/**
* @const MIME_TYPE_APPLICATION_X_MSMEDIAVIEW
* "application/x-msmediaview"。
*/
#define MIME_TYPE_APPLICATION_X_MSMEDIAVIEW "application/x-msmediaview"
/**
* @const MIME_TYPE_APPLICATION_X_MSMETAFILE
* "application/x-msmetafile"。
*/
#define MIME_TYPE_APPLICATION_X_MSMETAFILE "application/x-msmetafile"
/**
* @const MIME_TYPE_APPLICATION_X_MSMONEY
* "application/x-msmoney"。
*/
#define MIME_TYPE_APPLICATION_X_MSMONEY "application/x-msmoney"
/**
* @const MIME_TYPE_APPLICATION_X_MSPUBLISHER
* "application/x-mspublisher"。
*/
#define MIME_TYPE_APPLICATION_X_MSPUBLISHER "application/x-mspublisher"
/**
* @const MIME_TYPE_APPLICATION_X_MSSCHEDULE
* "application/x-msschedule"。
*/
#define MIME_TYPE_APPLICATION_X_MSSCHEDULE "application/x-msschedule"
/**
* @const MIME_TYPE_APPLICATION_X_MSTERMINAL
* "application/x-msterminal"。
*/
#define MIME_TYPE_APPLICATION_X_MSTERMINAL "application/x-msterminal"
/**
* @const MIME_TYPE_APPLICATION_X_MSWRITE
* "application/x-mswrite"。
*/
#define MIME_TYPE_APPLICATION_X_MSWRITE "application/x-mswrite"
/**
* @const MIME_TYPE_APPLICATION_X_NETCDF
* "application/x-netcdf"。
*/
#define MIME_TYPE_APPLICATION_X_NETCDF "application/x-netcdf"
/**
* @const MIME_TYPE_APPLICATION_X_PERFMON
* "application/x-perfmon"。
*/
#define MIME_TYPE_APPLICATION_X_PERFMON "application/x-perfmon"
/**
* @const MIME_TYPE_APPLICATION_X_PKCS12
* "application/x-pkcs12"。
*/
#define MIME_TYPE_APPLICATION_X_PKCS12 "application/x-pkcs12"
/**
* @const MIME_TYPE_APPLICATION_X_SH
* "application/x-sh"。
*/
#define MIME_TYPE_APPLICATION_X_SH "application/x-sh"
/**
* @const MIME_TYPE_APPLICATION_X_SHAR
* "application/x-shar"。
*/
#define MIME_TYPE_APPLICATION_X_SHAR "application/x-shar"
/**
* @const MIME_TYPE_APPLICATION_X_SHOCKWAVE_FLASH
* "application/x-shockwave-flash"。
*/
#define MIME_TYPE_APPLICATION_X_SHOCKWAVE_FLASH "application/x-shockwave-flash"
/**
* @const MIME_TYPE_APPLICATION_X_STUFFIT
* "application/x-stuffit"。
*/
#define MIME_TYPE_APPLICATION_X_STUFFIT "application/x-stuffit"
/**
* @const MIME_TYPE_APPLICATION_X_SV4CPIO
* "application/x-sv4cpio"。
*/
#define MIME_TYPE_APPLICATION_X_SV4CPIO "application/x-sv4cpio"
/**
* @const MIME_TYPE_APPLICATION_X_SV4CRC
* "application/x-sv4crc"。
*/
#define MIME_TYPE_APPLICATION_X_SV4CRC "application/x-sv4crc"
/**
* @const MIME_TYPE_APPLICATION_X_TAR
* "application/x-tar"。
*/
#define MIME_TYPE_APPLICATION_X_TAR "application/x-tar"
/**
* @const MIME_TYPE_APPLICATION_X_TCL
* "application/x-tcl"。
*/
#define MIME_TYPE_APPLICATION_X_TCL "application/x-tcl"
/**
* @const MIME_TYPE_APPLICATION_X_TEX
* "application/x-tex"。
*/
#define MIME_TYPE_APPLICATION_X_TEX "application/x-tex"
/**
* @const MIME_TYPE_APPLICATION_X_TEXINFO
* "application/x-texinfo"。
*/
#define MIME_TYPE_APPLICATION_X_TEXINFO "application/x-texinfo"
/**
* @const MIME_TYPE_APPLICATION_X_TROFF
* "application/x-troff"。
*/
#define MIME_TYPE_APPLICATION_X_TROFF "application/x-troff"
/**
* @const MIME_TYPE_APPLICATION_X_USTAR
* "application/x-ustar"。
*/
#define MIME_TYPE_APPLICATION_X_USTAR "application/x-ustar"
/**
* @const MIME_TYPE_APPLICATION_ZIP
* "application/zip"。
*/
#define MIME_TYPE_APPLICATION_ZIP "application/zip"
/**
* @const MIME_TYPE_AUDIO_BASIC
* "audio/basic"。
*/
#define MIME_TYPE_AUDIO_BASIC "audio/basic"
/**
* @const MIME_TYPE_AUDIO_MID
* "audio/mid"。
*/
#define MIME_TYPE_AUDIO_MID "audio/mid"
/**
* @const MIME_TYPE_AUDIO_MPEG
* "audio/mpeg"。
*/
#define MIME_TYPE_AUDIO_MPEG "audio/mpeg"
/**
* @const MIME_TYPE_AUDIO_X_AIFF
* "audio/x-aiff"。
*/
#define MIME_TYPE_AUDIO_X_AIFF "audio/x-aiff"
/**
* @const MIME_TYPE_AUDIO_X_MPEGURL
* "audio/x-mpegurl"。
*/
#define MIME_TYPE_AUDIO_X_MPEGURL "audio/x-mpegurl"
/**
* @const MIME_TYPE_AUDIO_X_WAV
* "audio/x-wav"。
*/
#define MIME_TYPE_AUDIO_X_WAV "audio/x-wav"
/**
* @const MIME_TYPE_IMAGE_BMP
* "image/bmp"。
*/
#define MIME_TYPE_IMAGE_BMP "image/bmp"
/**
* @const MIME_TYPE_IMAGE_CIS_COD
* "image/cis-cod"。
*/
#define MIME_TYPE_IMAGE_CIS_COD "image/cis-cod"
/**
* @const MIME_TYPE_IMAGE_GIF
* "image/gif"。
*/
#define MIME_TYPE_IMAGE_GIF "image/gif"
/**
* @const MIME_TYPE_IMAGE_IEF
* "image/ief"。
*/
#define MIME_TYPE_IMAGE_IEF "image/ief"
/**
* @const MIME_TYPE_IMAGE_JPEG
* "image/jpeg"。
*/
#define MIME_TYPE_IMAGE_JPEG "image/jpeg"
/**
* @const MIME_TYPE_IMAGE_PIPEG
* "image/pipeg"。
*/
#define MIME_TYPE_IMAGE_PIPEG "image/pipeg"
/**
* @const MIME_TYPE_IMAGE_SVG_XML
* "image/svg+xml"。
*/
#define MIME_TYPE_IMAGE_SVG_XML "image/svg+xml"
/**
* @const MIME_TYPE_IMAGE_TIFF
* "image/tiff"。
*/
#define MIME_TYPE_IMAGE_TIFF "image/tiff"
/**
* @const MIME_TYPE_IMAGE_X_CMX
* "image/x-cmx"。
*/
#define MIME_TYPE_IMAGE_X_CMX "image/x-cmx"
/**
* @const MIME_TYPE_IMAGE_X_ICON
* "image/x-icon"。
*/
#define MIME_TYPE_IMAGE_X_ICON "image/x-icon"
/**
* @const MIME_TYPE_IMAGE_X_RGB
* "image/x-rgb"。
*/
#define MIME_TYPE_IMAGE_X_RGB "image/x-rgb"
/**
* @const MIME_TYPE_IMAGE_X_XBITMAP
* "image/x-xbitmap"。
*/
#define MIME_TYPE_IMAGE_X_XBITMAP "image/x-xbitmap"
/**
* @const MIME_TYPE_IMAGE_X_XPIXMAP
* "image/x-xpixmap"。
*/
#define MIME_TYPE_IMAGE_X_XPIXMAP "image/x-xpixmap"
/**
* @const MIME_TYPE_IMAGE_X_XWINDOWDUMP
* "image/x-xwindowdump"。
*/
#define MIME_TYPE_IMAGE_X_XWINDOWDUMP "image/x-xwindowdump"
/**
* @const MIME_TYPE_MESSAGE_RFC822
* "message/rfc822"。
*/
#define MIME_TYPE_MESSAGE_RFC822 "message/rfc822"
/**
* @const MIME_TYPE_TEXT_CSS
* "text/css"。
*/
#define MIME_TYPE_TEXT_CSS "text/css"
/**
* @const MIME_TYPE_TEXT_H323
* "text/h323"。
*/
#define MIME_TYPE_TEXT_H323 "text/h323"
/**
* @const MIME_TYPE_TEXT_HTML
* "text/html"。
*/
#define MIME_TYPE_TEXT_HTML "text/html"
/**
* @const MIME_TYPE_TEXT_IULS
* "text/iuls"。
*/
#define MIME_TYPE_TEXT_IULS "text/iuls"
/**
* @const MIME_TYPE_TEXT_PLAIN
* "text/plain"。
*/
#define MIME_TYPE_TEXT_PLAIN "text/plain"
/**
* @const MIME_TYPE_TEXT_RICHTEXT
* "text/richtext"。
*/
#define MIME_TYPE_TEXT_RICHTEXT "text/richtext"
/**
* @const MIME_TYPE_TEXT_SCRIPTLET
* "text/scriptlet"。
*/
#define MIME_TYPE_TEXT_SCRIPTLET "text/scriptlet"
/**
* @const MIME_TYPE_TEXT_WEBVIEWHTML
* "text/webviewhtml"。
*/
#define MIME_TYPE_TEXT_WEBVIEWHTML "text/webviewhtml"
/**
* @const MIME_TYPE_TEXT_X_COMPONENT
* "text/x-component"。
*/
#define MIME_TYPE_TEXT_X_COMPONENT "text/x-component"
/**
* @const MIME_TYPE_TEXT_X_SETEXT
* "text/x-setext"。
*/
#define MIME_TYPE_TEXT_X_SETEXT "text/x-setext"
/**
* @const MIME_TYPE_TEXT_X_VCARD
* "text/x-vcard"。
*/
#define MIME_TYPE_TEXT_X_VCARD "text/x-vcard"
/**
* @const MIME_TYPE_VIDEO_MPEG
* "video/mpeg"。
*/
#define MIME_TYPE_VIDEO_MPEG "video/mpeg"
/**
* @const MIME_TYPE_VIDEO_QUICKTIME
* "video/quicktime"。
*/
#define MIME_TYPE_VIDEO_QUICKTIME "video/quicktime"
/**
* @const MIME_TYPE_VIDEO_X_MSVIDEO
* "video/x-msvideo"。
*/
#define MIME_TYPE_VIDEO_X_MSVIDEO "video/x-msvideo"
#endif /*MIME_TYPES_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/mem_allocator_pool.h
|
/**
* File: mem_allocator_pool.h
* Author: AWTK Develop Team
* Brief: mem_allocator_pool
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-16 Li XianJing <[email protected]> created
*
*/
#ifndef TK_MEM_ALLOCATOR_POOL_H
#define TK_MEM_ALLOCATOR_POOL_H
#include "tkc/mem_pool.h"
#include "tkc/mem_allocator.h"
BEGIN_C_DECLS
#define TK_MEM_POOLS_NR 5
/**
* @class mem_allocator_pool_t
* @parent mem_allocator_t
*
* 对现有的allocator进行包装，预先分配一部分内存，用于分配小块内存，可以避免内存碎片。
*
*/
typedef struct _mem_allocator_pool_t {
mem_allocator_t allocator;
mem_allocator_t* impl;
mem_pool_t* pools[TK_MEM_POOLS_NR];
} mem_allocator_pool_t;
#define MEM_ALLOCATOR_POOL(allocator) ((mem_allocator_pool_t*)(allocator))
static inline void* mem_allocator_pool_alloc(mem_allocator_t* allocator, uint32_t size,
const char* func, uint32_t line) {
uint32_t i = 0;
void* addr = NULL;
mem_pool_t** pools = MEM_ALLOCATOR_POOL(allocator)->pools;
mem_allocator_t* impl = MEM_ALLOCATOR_POOL(allocator)->impl;
for (i = 0; i < TK_MEM_POOLS_NR; i++) {
mem_pool_t* p = pools[i];
if (mem_pool_match_size(p, size)) {
addr = mem_pool_get(p);
if (addr != NULL) {
return addr;
} else {
break;
}
}
}
addr = mem_allocator_alloc(impl, size, func, line);
return addr;
}
static inline void* mem_allocator_pool_realloc(mem_allocator_t* allocator, void* ptr, uint32_t size,
const char* func, uint32_t line) {
uint32_t i = 0;
void* addr = NULL;
mem_pool_t** pools = MEM_ALLOCATOR_POOL(allocator)->pools;
mem_allocator_t* impl = MEM_ALLOCATOR_POOL(allocator)->impl;
if (ptr == NULL) {
return mem_allocator_pool_alloc(allocator, size, func, line);
}
for (i = 0; i < TK_MEM_POOLS_NR; i++) {
mem_pool_t* p = pools[i];
if (mem_pool_get_index(p, ptr) >= 0) {
if (mem_pool_match_size(p, size)) {
return ptr;
} else {
addr = mem_allocator_pool_alloc(allocator, size, func, line);
return_value_if_fail(addr != NULL, NULL);
memcpy(addr, ptr, p->block_size);
mem_pool_put(p, ptr);
return addr;
}
}
}
addr = mem_allocator_realloc(impl, ptr, size, func, line);
return addr;
}
static inline void mem_allocator_pool_free(mem_allocator_t* allocator, void* ptr) {
uint32_t i = 0;
mem_pool_t** pools = MEM_ALLOCATOR_POOL(allocator)->pools;
mem_allocator_t* impl = MEM_ALLOCATOR_POOL(allocator)->impl;
if (ptr == NULL) {
return;
}
for (i = 0; i < TK_MEM_POOLS_NR; i++) {
mem_pool_t* p = pools[i];
if (mem_pool_get_index(p, ptr) >= 0) {
mem_pool_put(p, ptr);
return;
}
}
mem_allocator_free(impl, ptr);
}
static inline ret_t mem_allocator_pool_dump(mem_allocator_t* allocator) {
uint32_t i = 0;
uint32_t used = 0;
mem_pool_t** pools = MEM_ALLOCATOR_POOL(allocator)->pools;
mem_allocator_t* impl = MEM_ALLOCATOR_POOL(allocator)->impl;
mem_allocator_dump(impl);
for (i = 0; i < TK_MEM_POOLS_NR; i++) {
mem_pool_t* p = pools[i];
used += p->used;
log_debug("%u: block_size=%u block_nr=%u used=%u\n", i, p->block_size, p->block_nr, p->used);
}
log_debug("total_used=%u\n", used);
return RET_OK;
}
static inline ret_t mem_allocator_pool_destroy(mem_allocator_t* allocator) {
uint32_t i = 0;
mem_pool_t** pools = MEM_ALLOCATOR_POOL(allocator)->pools;
mem_allocator_t* impl = MEM_ALLOCATOR_POOL(allocator)->impl;
for (i = 0; i < TK_MEM_POOLS_NR; i++) {
mem_pool_t* p = pools[i];
mem_allocator_free(impl, p);
pools[i] = NULL;
}
mem_allocator_destroy(impl);
allocator->vt = NULL;
return RET_OK;
}
static const mem_allocator_vtable_t s_mem_allocator_pool_vtable = {
.alloc = mem_allocator_pool_alloc,
.realloc = mem_allocator_pool_realloc,
.free = mem_allocator_pool_free,
.dump = mem_allocator_pool_dump,
.destroy = mem_allocator_pool_destroy};
static mem_pool_t* mem_pool_create(mem_allocator_t* impl, uint32_t block_size, uint32_t block_nr) {
uint32_t size = mem_pool_get_min_size(block_size, block_nr);
uint8_t* addr = (uint8_t*)mem_allocator_alloc(impl, size, __FUNCTION__, __LINE__);
return_value_if_fail(addr != NULL, NULL);
return mem_pool_init(addr, size, block_size, block_nr);
}
static inline mem_allocator_t* mem_allocator_pool_init(mem_allocator_pool_t* pool,
mem_allocator_t* impl, uint32_t pool8_nr,
uint32_t pool16_nr, uint32_t pool32_nr,
uint32_t pool48_nr, uint32_t pool64_nr) {
uint32_t i = 0;
mem_allocator_t* allocator = MEM_ALLOCATOR(pool);
uint32_t blocks_size[TK_MEM_POOLS_NR] = {8, 16, 32, 48, 64};
uint32_t blocks_nr[TK_MEM_POOLS_NR] = {pool8_nr, pool16_nr, pool32_nr, pool48_nr, pool64_nr};
return_value_if_fail(pool != NULL && impl != NULL, NULL);
memset(pool, 0x00, sizeof(*pool));
allocator->vt = &s_mem_allocator_pool_vtable;
pool->impl = impl;
for (i = 0; i < TK_MEM_POOLS_NR; i++) {
pool->pools[i] = mem_pool_create(impl, blocks_size[i], tk_max(32, blocks_nr[i]));
}
return allocator;
}
END_C_DECLS
#endif /*TK_MEM_ALLOCATOR_POOL_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_locker.c
|
/**
* File: object_locker.c
* Author: AWTK Develop Team
* Brief: decorate object with lock
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-06-12 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "tkc/object_locker.h"
static ret_t object_locker_on_destroy(tk_object_t* obj) {
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL && o->mutex != NULL, RET_BAD_PARAMS);
tk_mutex_nest_destroy(o->mutex);
emitter_off_by_ctx(EMITTER(o->obj), o);
TK_OBJECT_UNREF(o->obj);
return RET_OK;
}
static int32_t object_locker_compare(tk_object_t* obj, tk_object_t* other) {
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL && o->obj != NULL, -1);
return tk_object_compare(o->obj, other);
}
static ret_t object_locker_remove_prop(tk_object_t* obj, const char* name) {
ret_t ret = RET_NOT_FOUND;
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL && o->mutex != NULL, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(o->mutex) == RET_OK) {
ret = tk_object_remove_prop(o->obj, name);
tk_mutex_nest_unlock(o->mutex);
}
return ret;
}
static ret_t object_locker_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL && o->mutex != NULL, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(o->mutex) == RET_OK) {
ret = tk_object_set_prop(o->obj, name, v);
tk_mutex_nest_unlock(o->mutex);
}
return ret;
}
static ret_t object_locker_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(o->mutex) == RET_OK) {
ret = tk_object_get_prop(o->obj, name, v);
tk_mutex_nest_unlock(o->mutex);
}
return ret;
}
static ret_t object_locker_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
ret_t ret = RET_OK;
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(o->mutex) == RET_OK) {
ret = tk_object_foreach_prop(o->obj, on_prop, ctx);
tk_mutex_nest_unlock(o->mutex);
}
return ret;
}
static bool_t object_locker_can_exec(tk_object_t* obj, const char* name, const char* args) {
bool_t ret = RET_OK;
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_mutex_nest_lock(o->mutex) == RET_OK) {
ret = tk_object_can_exec(o->obj, name, args);
tk_mutex_nest_unlock(o->mutex);
}
return ret;
}
static ret_t object_locker_exec(tk_object_t* obj, const char* name, const char* args) {
ret_t ret = RET_OK;
object_locker_t* o = OBJECT_LOCKER(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, "lock")) {
return tk_mutex_nest_lock(o->mutex);
} else if (tk_str_eq(name, "unlock")) {
return tk_mutex_nest_unlock(o->mutex);
} else if (tk_mutex_nest_lock(o->mutex) == RET_OK) {
ret = tk_object_exec(o->obj, name, args);
tk_mutex_nest_unlock(o->mutex);
}
return ret;
}
static const object_vtable_t s_object_locker_vtable = {.type = OBJECT_LOCKER_TYPE,
.desc = OBJECT_LOCKER_TYPE,
.size = sizeof(object_locker_t),
.is_collection = FALSE,
.on_destroy = object_locker_on_destroy,
.exec = object_locker_exec,
.can_exec = object_locker_can_exec,
.compare = object_locker_compare,
.get_prop = object_locker_get_prop,
.set_prop = object_locker_set_prop,
.remove_prop = object_locker_remove_prop,
.foreach_prop = object_locker_foreach_prop};
static ret_t object_locker_forward_events(void* ctx, event_t* e) {
object_locker_t* o = OBJECT_LOCKER(ctx);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
emitter_dispatch_simple_event(EMITTER(o), e->type);
return RET_OK;
}
tk_object_t* object_locker_create(tk_object_t* obj) {
tk_object_t* o = NULL;
object_locker_t* wrapper = NULL;
return_value_if_fail(obj != NULL, NULL);
o = tk_object_create(&s_object_locker_vtable);
return_value_if_fail(o != NULL, NULL);
wrapper = OBJECT_LOCKER(o);
return_value_if_fail(wrapper != NULL, NULL);
wrapper->mutex = tk_mutex_nest_create();
if (wrapper->mutex != NULL) {
wrapper->obj = tk_object_ref(obj);
emitter_on(EMITTER(obj), EVT_ITEMS_CHANGED, object_locker_forward_events, o);
emitter_on(EMITTER(obj), EVT_PROPS_CHANGED, object_locker_forward_events, o);
}
return o;
}
object_locker_t* object_locker_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_locker_vtable, NULL);
return (object_locker_t*)(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/waitable_action_queue.h
|
/**
* File: waitable_action_queue.h
* Author: AWTK Develop Team
* Brief: waitable_action_queue
*
* Copyright (c) 2020 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2020-02-07 Li XianJing <[email protected]> created
*
*/
#ifndef TK_WAITABLE_ACTION_QUEUE_H
#define TK_WAITABLE_ACTION_QUEUE_H
#include "tkc/mutex.h"
#include "tkc/semaphore.h"
#include "tkc/action_queue.h"
BEGIN_C_DECLS
/**
* @class waitable_action_queue_t
*
* waitable actionqueue
*/
typedef struct _waitable_action_queue_t {
action_queue_t* queue;
tk_mutex_t* mutex;
tk_semaphore_t* sema_recv;
tk_semaphore_t* sema_send;
} waitable_action_queue_t;
/**
* @method waitable_action_queue_create
* @annotation ["constructor"]
* 创建waitable_action_queue对象。
*
* @param {uint16_t} capacity action的容量。
*
* @return {waitable_action_queue_t*} waitable_action_queue对象。
*/
waitable_action_queue_t* waitable_action_queue_create(uint16_t capacity);
/**
* @method waitable_action_queue_recv
* 接收一个请求。
*
* @param {waitable_action_queue_t*} q waitable_action_queue对象。
* @param {qaction_t**} action 用于返回action对象。
* @param {uint32_t} timeout_ms 超时时间(毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_action_queue_recv(waitable_action_queue_t* q, qaction_t** action,
uint32_t timeout_ms);
/**
* @method waitable_action_queue_send
* 发送一个请求。
*
* @param {waitable_action_queue_t*} q waitable_action_queue对象。
* @param {qaction_t*} action action对象。
* @param {uint32_t} timeout_ms 超时时间(毫秒)
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_action_queue_send(waitable_action_queue_t* q, qaction_t* action,
uint32_t timeout_ms);
/**
* @method waitable_action_queue_destroy
* 销毁。
*
* @param {waitable_action_queue_t*} q waitable_action_queue对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t waitable_action_queue_destroy(waitable_action_queue_t* q);
END_C_DECLS
#endif /*TK_WAITABLE_ACTION_QUEUE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/str_str.c
|
/**
* File: str_to_str.c
* Author: AWTK Develop Team
* Brief: map one str to another str
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-31 Li XianJing <[email protected]> created
*
*/
#include "tkc/str_str.h"
const char* str_str_value(const str_str_t* items, const char* name) {
const str_str_t* iter = items;
return_value_if_fail(items != NULL && name != NULL, NULL);
while (iter->name != NULL) {
if (tk_str_eq(iter->name, name)) {
return iter->value;
}
iter++;
}
return NULL;
}
const char* str_str_name(const str_str_t* items, const char* value) {
const str_str_t* iter = items;
return_value_if_fail(items != NULL && value != NULL, NULL);
while (iter->value != NULL) {
if (tk_str_eq(iter->value, value)) {
return iter->name;
}
iter++;
}
return NULL;
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/value.h
|
/**
* File: value.h
* Author: AWTK Develop Team
* Brief: generic value type
*
* Copyright (c) 2018 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2018-01-27 Li XianJing <[email protected]> adapt from uclib
*
*/
#include "tkc/types_def.h"
#include "tkc/rect.h"
#ifndef TK_VALUE_H
#define TK_VALUE_H
BEGIN_C_DECLS
/**
* @enum value_type_t
* @prefix VALUE_TYPE_
* @annotation ["scriptable"]
* 类型常量定义。
*/
typedef enum _value_type_t {
/**
* @const VALUE_TYPE_INVALID
* 无效类型。
*/
VALUE_TYPE_INVALID = 0,
/**
* @const VALUE_TYPE_BOOL
* BOOL类型。
*/
VALUE_TYPE_BOOL,
/**
* @const VALUE_TYPE_INT8
* int8_t类型。
*/
VALUE_TYPE_INT8,
/**
* @const VALUE_TYPE_UINT8
* uint8_t类型。
*/
VALUE_TYPE_UINT8,
/**
* @const VALUE_TYPE_INT16
* int16_t类型。
*/
VALUE_TYPE_INT16,
/**
* @const VALUE_TYPE_UINT16
* uint16_t类型。
*/
VALUE_TYPE_UINT16,
/**
* @const VALUE_TYPE_INT32
* int32_t类型。
*/
VALUE_TYPE_INT32,
/**
* @const VALUE_TYPE_UINT32
* uint32_t类型。
*/
VALUE_TYPE_UINT32,
/**
* @const VALUE_TYPE_INT64
* int64_t类型。
*/
VALUE_TYPE_INT64,
/**
* @const VALUE_TYPE_UINT64
* uint64_t类型。
*/
VALUE_TYPE_UINT64,
/**
* @const VALUE_TYPE_POINTER
* void*类型。
*/
VALUE_TYPE_POINTER,
/**
* @const VALUE_TYPE_FLOAT
* float_t类型。
*/
VALUE_TYPE_FLOAT,
/**
* @const VALUE_TYPE_FLOAT32
* float类型。
*/
VALUE_TYPE_FLOAT32,
/**
* @const VALUE_TYPE_DOUBLE
* double类型。
*/
VALUE_TYPE_DOUBLE,
/**
* @const VALUE_TYPE_STRING
* char*类型。
*/
VALUE_TYPE_STRING,
/**
* @const VALUE_TYPE_WSTRING
* wchar_t*类型。
*/
VALUE_TYPE_WSTRING,
/**
* @const VALUE_TYPE_OBJECT
* tk_object_t*类型。
*/
VALUE_TYPE_OBJECT,
/**
* @const VALUE_TYPE_SIZED_STRING
* 带长度的字符串。
*/
VALUE_TYPE_SIZED_STRING,
/**
* @const VALUE_TYPE_BINARY
* 二进制数据。
*/
VALUE_TYPE_BINARY,
/**
* @const VALUE_TYPE_UBJSON
* 二进制数据(UBJSON)。
*/
VALUE_TYPE_UBJSON,
/**
* @const VALUE_TYPE_TOKEN
* 特殊用途。
*/
VALUE_TYPE_TOKEN,
/**
* @const VALUE_TYPE_GRADIENT
* 渐变颜色。
*/
VALUE_TYPE_GRADIENT,
/**
* @const VALUE_TYPE_ID
* id。
*/
VALUE_TYPE_ID,
/**
* @const VALUE_TYPE_FUNC
* func。
*/
VALUE_TYPE_FUNC,
/**
* @const VALUE_TYPE_FUNC_DEF
* func definition。
*/
VALUE_TYPE_FUNC_DEF,
/**
* @const VALUE_TYPE_POINTER_REF
* void*类型。
*/
VALUE_TYPE_POINTER_REF,
/**
* @const VALUE_TYPE_BITMAP
* 位图类型。
*/
VALUE_TYPE_BITMAP,
/**
* @const VALUE_TYPE_RECT
* 矩形类型。
*/
VALUE_TYPE_RECT,
} value_type_t;
typedef struct _binary_data_t {
uint32_t size;
void* data;
} binary_data_t;
typedef struct _sized_str_t {
uint32_t size;
char* str;
} sized_str_t;
typedef struct _id_info_t {
int32_t suboffset : 16;
int32_t index : 16;
char* id;
} id_info_t;
typedef struct _func_info_t {
uint32_t memo;
void* func;
} func_info_t;
typedef struct _pointer_ref_t {
void* data;
int32_t refcount;
tk_destroy_t destroy;
} pointer_ref_t;
/**
* @class value_t
* @order -9
* @annotation ["scriptable"]
* 一个通用数据类型，用来存放整数、浮点数、字符串和其它对象。
*
* 在C/C++中，一般不需动态创建对象，直接声明并初始化即可。如：
*
* ```c
* value_t v;
* value_set_int(&v, 100);
* ```
*
*> 在脚本语言中，需要动态创建对象。
*
*/
struct _value_t {
value_type_t type : 8;
/*sub_type用细分类型。目前不做定义，请根据上下文使用。*/
uint32_t sub_type : 8;
bool_t free_handle : 1;
union {
int8_t i8;
uint8_t u8;
int16_t i16;
uint16_t u16;
int32_t i32;
uint32_t u32;
int64_t i64;
uint64_t u64;
uint32_t token;
float f;
float f32;
double f64;
bool_t b;
void* ptr;
const char* str;
const wchar_t* wstr;
tk_object_t* object;
binary_data_t binary_data;
sized_str_t sized_str;
id_info_t id;
pointer_ref_t* ptr_ref;
func_info_t func;
void* bitmap;
rect_t rect;
} value;
};
/**
* @method value_set_bool
* 设置类型为bool的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {bool_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_bool(value_t* v, bool_t value);
/**
* @method value_bool
* 获取类型为bool的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {bool_t} 值。
*/
bool_t value_bool(const value_t* v);
/**
* @method value_set_int8
* 设置类型为int8的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {int8_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_int8(value_t* v, int8_t value);
/**
* @method value_int8
* 获取类型为int8的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {int8_t} 值。
*/
int8_t value_int8(const value_t* v);
/**
* @method value_set_uint8
* 设置类型为uint8的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {uint8_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_uint8(value_t* v, uint8_t value);
/**
* @method value_uint8
* 获取类型为uint8的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {uint8_t} 值。
*/
uint8_t value_uint8(const value_t* v);
/**
* @method value_set_int16
* 设置类型为int16的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {int16_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_int16(value_t* v, int16_t value);
/**
* @method value_int16
* 获取类型为int16的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {int16_t} 值。
*/
int16_t value_int16(const value_t* v);
/**
* @method value_set_uint16
* 设置类型为uint16的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {uint16_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_uint16(value_t* v, uint16_t value);
/**
* @method value_uint16
* 获取类型为uint16的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {uint16_t} 值。
*/
uint16_t value_uint16(const value_t* v);
/**
* @method value_set_int32
* 设置类型为int32的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {int32_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_int32(value_t* v, int32_t value);
/**
* @method value_int32
* 获取类型为int32的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {int32_t} 值。
*/
int32_t value_int32(const value_t* v);
/**
* @method value_set_uint32
* 设置类型为uint32的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {uint32_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_uint32(value_t* v, uint32_t value);
/**
* @method value_uint32
* 获取类型为uint32的值。
* @param {const value_t*} v value对象。
*
* @return {uint32_t} 值。
*/
uint32_t value_uint32(const value_t* v);
/**
* @method value_set_int64
* 设置类型为int64的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {int64_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_int64(value_t* v, int64_t value);
/**
* @method value_int64
* 获取类型为int64的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {int64_t} 值。
*/
int64_t value_int64(const value_t* v);
/**
* @method value_set_uint64
* 设置类型为uint64的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {uint64_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_uint64(value_t* v, uint64_t value);
/**
* @method value_uint64
* 获取类型为uint64的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {uint64_t} 值。
*/
uint64_t value_uint64(const value_t* v);
/**
* @method value_set_pointer
* 设置类型为pointer的值。
* @param {value_t*} v value对象。
* @param {void*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_pointer(value_t* v, void* value);
/**
* @method value_set_pointer_ex
* 设置类型为pointer的值。
* @param {value_t*} v value对象。
* @param {void*} value 待设置的值。
* @param {tk_destroy_t} destroy 销毁函数。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_pointer_ex(value_t* v, void* value, tk_destroy_t destroy);
/**
* @method value_pointer
* 获取类型为pointer的值。
* @param {const value_t*} v value对象。
*
* @return {void*} 值。
*/
void* value_pointer(const value_t* v);
/**
* @method value_set_float
* 设置类型为float\_t的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {float_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_float(value_t* v, float_t value);
/**
* @method value_float
* 获取类型为float\_t的值。
* @param {const value_t*} v value对象。
*
* @return {float_t} 值。
*/
float_t value_float(const value_t* v);
/**
* @method value_set_float32
* 设置类型为float的值。
* @param {value_t*} v value对象。
* @param {float} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_float32(value_t* v, float value);
/**
* @method value_float32
* 获取类型为float的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {float} 值。
*/
float value_float32(const value_t* v);
/**
* @method value_set_double
* 设置类型为double的值。
* @annotation ["scriptable"]
* @alias value_set_float64
* @param {value_t*} v value对象。
* @param {double} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_double(value_t* v, double value);
/**
* @method value_double
* 获取类型为double的值。
* @annotation ["scriptable"]
* @alias value_float64
* @param {const value_t*} v value对象。
*
* @return {double} 值。
*/
double value_double(const value_t* v);
/**
* @method value_set_str
* 设置类型为字符串的值。
* @param {value_t*} v value对象。
* @param {const char*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_str(value_t* v, const char* value);
/**
* @method value_dup_str
* 设置类型为字符串的值(并拷贝字符串)。
*
* @alias value_set_str
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {const char*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_dup_str(value_t* v, const char* value);
/**
* @method value_dup_str_with_len
* 设置类型为字符串的值(并拷贝字符串)。
*
* @param {value_t*} v value对象。
* @param {const char*} value 待设置的值。
* @param {uint32_t} len 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_dup_str_with_len(value_t* v, const char* value, uint32_t len);
/**
* @method value_set_wstr
* 设置类型为宽字符串的值。
* @param {value_t*} v value对象。
* @param {const wchar_t*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_wstr(value_t* v, const wchar_t* value);
/**
* @method value_dup_wstr
* 设置类型为宽字符串的值(并拷贝宽字符串)。
*
* @alias value_dup_wstr
* @param {value_t*} v value对象。
* @param {const wchar_t*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_dup_wstr(value_t* v, const wchar_t* value);
/**
* @method value_str
* 获取类型为字符串的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {const char*} 值。
*/
const char* value_str(const value_t* v);
/**
* @method value_str_ex
* 获取类型为字符串的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
* @param {char*} buff 用于格式转换的缓冲区（如果 v 对象为 string 类型的话，不会把字符串数据拷贝到 buff 中）。
* @param {uint32_t} size 缓冲区大小。
*
* @return {const char*} 值。
*/
const char* value_str_ex(const value_t* v, char* buff, uint32_t size);
/**
* @method value_wstr
* 获取类型为宽字符串的值。
* @param {const value_t*} v value对象。
*
* @return {const wchar_t*} 值。
*/
const wchar_t* value_wstr(const value_t* v);
/**
* @method value_is_null
* 判断value是否为空值。
* @annotation ["scriptable"]
* @param {value_t*} value value对象。
*
* @return {bool_t} 为空值返回TRUE，否则返回FALSE。
*/
bool_t value_is_null(value_t* value);
/**
* @method value_equal
* 判断两个value是否相同。
* @annotation ["scriptable"]
* @param {const value_t*} value value对象。
* @param {const value_t*} other value对象。
*
* @return {bool_t} 为空值返回TRUE，否则返回FALSE。
*/
bool_t value_equal(const value_t* value, const value_t* other);
/**
* @method value_int
* 转换为int的值。
* @param {const value_t*} v value对象。
*
* @return {int} 值。
*/
int value_int(const value_t* v);
/**
* @method value_set_int
* 设置类型为int的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {int32_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_int(value_t* v, int32_t value);
/**
* @method value_set_object
* 设置类型为object的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {tk_object_t*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_object(value_t* v, tk_object_t* value);
/**
* @method value_object
* 转换为object的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {tk_object_t*} 值。
*/
tk_object_t* value_object(const value_t* v);
/**
* @method value_set_token
* 设置类型为token的值。
* @annotation ["scriptable"]
* @param {value_t*} v value对象。
* @param {uint32_t} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_token(value_t* v, uint32_t value);
/**
* @method value_token
* 获取token的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {uint32_t} 值。
*/
uint32_t value_token(const value_t* v);
/**
* @method value_set_sized_str
* 设置类型为带长度的字符串的值。
* @param {value_t*} v value对象。
* @param {char*} str 待设置的值。
* @param {uint32_t} size 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_sized_str(value_t* v, char* str, uint32_t size);
/**
* @method value_sized_str
* 获取为sized_str的值。
* @param {const value_t*} v value对象。
*
* @return {sized_str_t*} 值。
*/
sized_str_t* value_sized_str(const value_t* v);
/**
* @method value_set_binary_data
* 设置类型为binary_data的值。
* @param {value_t*} v value对象。
* @param {void*} data 待设置的值。
* @param {uint32_t} size 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_binary_data(value_t* v, void* data, uint32_t size);
/**
* @method value_dup_binary_data
* 设置类型为binary_data的值(复制数据)。
* @param {value_t*} v value对象。
* @param {const void*} data 待设置的值。
* @param {uint32_t} size 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_dup_binary_data(value_t* v, const void* data, uint32_t size);
/**
* @method value_binary_data
* 获取为binary_data的值。
* @param {const value_t*} v value对象。
*
* @return {binary_data_t*} 值。
*/
binary_data_t* value_binary_data(const value_t* v);
/**
* @method value_set_ubjson
* 设置类型为ubjson的值。
* @param {value_t*} v value对象。
* @param {void*} data 待设置的值。
* @param {uint32_t} size 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_ubjson(value_t* v, void* data, uint32_t size);
/**
* @method value_ubjson
* 获取为ubjson的值。
* @param {const value_t*} v value对象。
*
* @return {binary_data_t*} 值。
*/
binary_data_t* value_ubjson(const value_t* v);
/**
* @method value_set_gradient
* 设置类型为gradient的值。
* @param {value_t*} v value对象。
* @param {void*} data 待设置的值。
* @param {uint32_t} size 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_gradient(value_t* v, void* data, uint32_t size);
/**
* @method value_gradient
* 获取为gradient的值。
* @param {const value_t*} v value对象。
*
* @return {binary_data_t*} 值。
*/
binary_data_t* value_gradient(const value_t* v);
/**
* @method value_copy
* 拷贝value的值。
* @param {value_t*} dst 目的value对象。
* @param {const value_t*} src 源value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_copy(value_t* dst, const value_t* src);
/**
* @method value_deep_copy
* 深拷贝value的值。
* dst使用完成后，要调用value_reset，确保不会发生内存泄漏。
* @param {value_t*} dst 目的value对象。
* @param {const value_t*} src 源value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_deep_copy(value_t* dst, const value_t* src);
/**
* @method value_create
* @annotation ["constructor", "scriptable", "gc"]
* 创建value对象。
*
* @return {value_t*} 对象。
*/
value_t* value_create(void);
/**
* @method value_destroy
* 销毁value对象。
* @annotation ["deconstructor", "scriptable", "gc"]
* @param {value_t*} v value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_destroy(value_t* v);
/**
* @method value_reset
* 重置value对象。
* @annotation ["deconstructor", "scriptable"]
* @param {value_t*} v value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_reset(value_t* v);
/**
* @method value_cast
* 转换为value对象。
*
* > 供脚本语言使用
* @annotation ["cast", "scriptable"]
* @param {value_t*} value value对象。
*
* @return {value_t*} 对象。
*/
value_t* value_cast(value_t* value);
/**
* @method value_type_size
* 获取指定类型数据大小。
* @annotation ["static"]
* @param {value_type_t} type 类型。
*
* @return {uint32_t} 返回对应数据类型的长度。
*/
uint32_t value_type_size(value_type_t type);
/**
* @method value_type_name
* 获取指定类型数据的名称。
* @annotation ["static"]
* @param {value_type_t} type 类型。
*
* @return {const char*} 返回对应数据类型的名称。
*/
const char* value_type_name(value_type_t type);
/**
* @method value_id
* 获取类型为ID的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {const char*} 值。
*/
const char* value_id(const value_t* v);
/**
* @method value_set_id
* 设置类型为ID的值。
* @param {value_t*} v value对象。
* @param {const char*} value 待设置的值。
* @param {uint32_t} len 长度。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_id(value_t* v, const char* value, uint32_t len);
/**
* @method value_func
* 获取类型为func的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {void*} 值。
*/
void* value_func(const value_t* v);
/**
* @method value_set_func
* 设置类型为func的值。
* @param {value_t*} v value对象。
* @param {void*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_func(value_t* v, void* value);
/**
* @method value_func_def
* 获取类型为func_def的值。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {void*} 值。
*/
void* value_func_def(const value_t* v);
/**
* @method value_set_func_def
* 设置类型为func_def的值。
* @param {value_t*} v value对象。
* @param {void*} value 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_func_def(value_t* v, void* value);
/**
* @method value_bitmap
* 获取类型为位图对象。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {void*} 位图对象。
*/
void* value_bitmap(const value_t* v);
/**
* @method value_set_bitmap
* 设置类型为位图对象。
* @param {value_t*} v value对象。
* @param {void*} bitmap 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_bitmap(value_t* v, void* bitmap);
/**
* @method value_rect
* 获取类型为矩形区域数据。
* @annotation ["scriptable"]
* @param {const value_t*} v value对象。
*
* @return {rect_t*} 返回矩形区域数据。
*/
rect_t* value_rect(const value_t* v);
/**
* @method value_set_rect
* 设置类型为矩形区域数据。
* @param {value_t*} v value对象。
* @param {rect_t} r 待设置的值。
*
* @return {value_t*} value对象本身。
*/
value_t* value_set_rect(value_t* v, rect_t r);
/**
* @method value_lshift
* 将v左移指定的位数，并将结果放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_lshift(value_t* v, value_t* result, uint32_t n);
/**
* @method value_rshift
* 将v右移指定的位数，并将结果放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_rshift(value_t* v, value_t* result, uint32_t n);
/**
* @method value_lshift_r
* 将v循环左移指定的位数，并将结果放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_lshift_r(value_t* v, value_t* result, uint32_t n);
/**
* @method value_rshift_r
* 将v循环右移指定的位数，并将结果放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_rshift_r(value_t* v, value_t* result, uint32_t n);
/**
* @method value_toggle_bit
* 将v指定的位数取反，并将结果放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_toggle_bit(value_t* v, value_t* result, uint32_t n);
/**
* @method value_get_bit
* 将v指定的位数取出，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_get_bit(value_t* v, value_t* result, uint32_t n);
/**
* @method value_set_bit
* 将v指定的位数设置为bit，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
* @param {uint32_t} n 位数。
* @param {bool_t} bit 值。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_set_bit(value_t* v, value_t* result, uint32_t n, bool_t bit);
/**
* @method value_bit_not
* 将v按位取反，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_bit_not(value_t* v, value_t* result);
/**
* @method value_bit_or
* 将v和other按位取或，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} other value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_bit_or(value_t* v, value_t* other, value_t* result);
/**
* @method value_bit_and
* 将v和other按位取与，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} other value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_bit_and(value_t* v, value_t* other, value_t* result);
/**
* @method value_bit_xor
* 将v和other按位取异或，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} other value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_bit_xor(value_t* v, value_t* other, value_t* result);
/**
* @method value_abs
* 将v取绝对值，并放入result对象。
* @param {value_t*} v value对象(必须是数值类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_abs(value_t* v, value_t* result);
/**
* @method value_add
* 将v和other求和，并放入result对象。
* @param {value_t*} v value对象(必须是数值类型)。
* @param {value_t*} other value对象(必须是数值类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_add(value_t* v, value_t* other, value_t* result);
/**
* @method value_sub
* 将v和other求差，并放入result对象。
* @param {value_t*} v value对象(必须是数值类型)。
* @param {value_t*} other value对象(必须是数值类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_sub(value_t* v, value_t* other, value_t* result);
/**
* @method value_mul
* 将v和other求积，并放入result对象。
* @param {value_t*} v value对象(必须是数值类型)。
* @param {value_t*} other value对象(必须是数值类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_mul(value_t* v, value_t* other, value_t* result);
/**
* @method value_div
* 将v和other求商，并放入result对象。
* @param {value_t*} v value对象(必须是数值类型)。
* @param {value_t*} other value对象(必须是数值类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_div(value_t* v, value_t* other, value_t* result);
/**
* @method value_expt
* 计算v的other次幂，并放入result对象。
* @param {value_t*} v value对象(必须是数值类型)。
* @param {value_t*} other value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_expt(value_t* v, value_t* other, value_t* result);
/**
* @method value_mod
* 将v和other求模，并放入result对象。
* @param {value_t*} v value对象(必须是整数类型)。
* @param {value_t*} other value对象(必须是整数类型)。
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_mod(value_t* v, value_t* other, value_t* result);
/**
* @method value_min
* 从数组中选择最小值，并放入result对象。
* @param {value_t*} arr 数组。
* @param {uint32_t} size 数组元素个数
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_min(value_t* arr, uint32_t size, value_t* result);
/**
* @method value_max
* 从数组中选择最大值，并放入result对象。
* @param {value_t*} arr 数组。
* @param {uint32_t} size 数组元素个数
* @param {value_t*} result 返回结果的value对象。
*
* @return {ret_t} 返回RET_OK表示成功，否则表示失败。
*/
ret_t value_max(value_t* arr, uint32_t size, value_t* result);
END_C_DECLS
#endif /*TK_VALUE_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/value_desc.h
|
/**
* File: value_desc.h
* Author: AWTK Develop Team
* Brief: value_desc
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-08-22 Li XianJing <[email protected]> created
*
*/
#ifndef TK_VALUE_DESC_H
#define TK_VALUE_DESC_H
#include "value.h"
#include "tkc/types_def.h"
BEGIN_C_DECLS
/**
* @enum value_desc_type_t
* @prefix VALUE_DESC_TYPE_
* 属性描述类型常量定义。
*/
typedef enum _value_desc_type_t {
/**
* @const VALUE_DESC_TYPE_INT8
* 有符号8位整数类型。
*/
VALUE_DESC_TYPE_INT8,
/**
* @const VALUE_DESC_TYPE_UINT8
* 无符号8位整数类型。
*/
VALUE_DESC_TYPE_UINT8,
/**
* @const VALUE_DESC_TYPE_INT16
* 有符号16位整数类型。
*/
VALUE_DESC_TYPE_INT16,
/**
* @const VALUE_DESC_TYPE_UINT16
* 无符号16位整数类型。
*/
VALUE_DESC_TYPE_UINT16,
/**
* @const VALUE_DESC_TYPE_INT32
* 有符号32位整数类型。
*/
VALUE_DESC_TYPE_INT32,
/**
* @const VALUE_DESC_TYPE_UINT32
* 无符号32位整数类型。
*/
VALUE_DESC_TYPE_UINT32,
/**
* @const VALUE_DESC_TYPE_INT64
* 有符号64位整数类型。
*/
VALUE_DESC_TYPE_INT64,
/**
* @const VALUE_DESC_TYPE_UINT64
* 无符号64位整数类型。
*/
VALUE_DESC_TYPE_UINT64,
/**
* @const VALUE_DESC_TYPE_FLOAT
* 单精度浮点数类型。
*/
VALUE_DESC_TYPE_FLOAT,
/**
* @const VALUE_DESC_TYPE_DOUBLE
* 双精度浮点数类型。
*/
VALUE_DESC_TYPE_DOUBLE,
/**
* @const VALUE_DESC_TYPE_BOOL
* 布尔类型。
*/
VALUE_DESC_TYPE_BOOL,
/**
* @const VALUE_DESC_TYPE_STRING
* 字符串类型。
*/
VALUE_DESC_TYPE_STRING,
/**
* @const VALUE_DESC_TYPE_BINARY
* 二进制类型。
*/
VALUE_DESC_TYPE_BINARY,
/**
* @const VALUE_DESC_TYPE_INT_ENUMS
* 整数枚举类型。
*/
VALUE_DESC_TYPE_INT_ENUMS,
/**
* @const VALUE_DESC_TYPE_STRING_ENUMS
* 字符串枚举类型。
*/
VALUE_DESC_TYPE_STRING_ENUMS
} value_desc_type_t;
/**
* @enum value_format_type_t
* @prefix VALUE_FORMAT_TYPE_
* 属性描述格式常量定义。
*/
typedef enum _value_format_type_t {
/**
* @const VALUE_FORMAT_TYPE_NONE
* 无特殊格式。
*/
VALUE_FORMAT_TYPE_NONE,
/**
* @const VALUE_FORMAT_TYPE_HEX
* 16进制格式。
*/
VALUE_FORMAT_TYPE_HEX,
/**
* @const VALUE_FORMAT_TYPE_UNSIGNED
* 非负格式(用于进一步限制float/double)。
*/
VALUE_FORMAT_TYPE_UNSIGNED,
/**
* @const VALUE_FORMAT_TYPE_PHONE
* 手机号码格式。
*/
VALUE_FORMAT_TYPE_PHONE,
/**
* @const VALUE_FORMAT_TYPE_EMAIL
* 邮件格式。
*/
VALUE_FORMAT_TYPE_EMAIL,
/**
* @const VALUE_FORMAT_TYPE_IP4_ADDRESS
* ip4地址格式。
*/
VALUE_FORMAT_TYPE_IP4_ADDRESS,
/**
* @const VALUE_FORMAT_TYPE_DOMAIN_NAME
* 域名格式。
*/
VALUE_FORMAT_TYPE_DOMAIN_NAME,
/**
* @const VALUE_FORMAT_TYPE_URL
* URL格式。
*/
VALUE_FORMAT_TYPE_URL,
/**
* @const VALUE_FORMAT_TYPE_JSON
* JSON格式。
*/
VALUE_FORMAT_TYPE_JSON,
/**
* @const VALUE_FORMAT_TYPE_XML
* XML格式。
*/
VALUE_FORMAT_TYPE_XML,
/**
* @const VALUE_FORMAT_TYPE_UBJSON
* UBJSON格式。
*/
VALUE_FORMAT_TYPE_UBJSON,
/**
* @const VALUE_FORMAT_TYPE_JS
* JS格式。
*/
VALUE_FORMAT_TYPE_JS,
/**
* @const VALUE_FORMAT_TYPE_CSV
* CSV格式。
*/
VALUE_FORMAT_TYPE_CSV
} value_format_type_t;
/**
* @enum prop_desc_flags_t
* @prefix PROP_DESC_FLAG_
* 属性描述范围常量定义。
*/
typedef enum _prop_desc_flags_t {
/**
* @const PROP_DESC_FLAG_OBJECT
* 单个对象的属性。
*/
PROP_DESC_FLAG_OBJECT = 1,
/**
* @const PROP_DESC_FLAG_CLASS
* 同一个类所有实例共享属性。
*/
PROP_DESC_FLAG_CLASS = (1 << 1),
/**
* @const PROP_DESC_FLAG_GLOBAL
* 全局属性。
*/
PROP_DESC_FLAG_GLOBAL = (1 << 2),
/**
* @const PROP_DESC_FLAG_READABLE
* 可读取。
*/
PROP_DESC_FLAG_READABLE = (1 << 3),
/**
* @const PROP_DESC_FLAG_WRITBALE
* 可修改。
*/
PROP_DESC_FLAG_WRITBALE = (1 << 4),
/**
* @const PROP_DESC_FLAG_CONFIGURABLE
* 可配置。
*/
PROP_DESC_FLAG_CONFIGURABLE = (1 << 5),
/**
* @const PROP_DESC_FLAG_PERSISTENT
* 需要持久化。
*/
PROP_DESC_FLAG_PERSISTENT = (1 << 6)
} prop_desc_flags_t;
#define PROP_FLAGS_DEFAULT \
(PROP_DESC_FLAG_OBJECT | PROP_DESC_FLAG_READABLE | PROP_DESC_FLAG_WRITBALE)
#define PROP_FLAGS_CONFIGURABLE \
(PROP_FLAGS_DEFAULT | PROP_DESC_FLAG_CONFIGURABLE | PROP_DESC_FLAG_PERSISTENT)
/**
* @enum arg_desc_flags_t
* @prefix ARG_DESC_FLAGS_
* 参数描述范围常量定义。
*/
typedef enum _arg_desc_flags_t {
/**
* @const ARG_DESC_FLAGS_REQUIRED
* 必须提供。
*/
ARG_DESC_FLAGS_REQUIRED = 1
} arg_desc_flags_t;
/**
* @class value_desc_t
* 属性描述。
*/
typedef struct _value_desc_t {
/**
* @property {uint8_t} type
* @annotation ["readable"]
* 类型。
*/
uint8_t type;
/**
* @property {uint8_t} format
* @annotation ["readable"]
* 格式。
*/
uint8_t format;
/**
* @property {uint16_t} flags
* @annotation ["readable"]
* flags。
*/
uint16_t flags;
/**
* @property {const char*} name
* @annotation ["readable"]
* 名称。
*/
const char* name;
/**
* @property {const char*} display_name
* @annotation ["readable"]
* 显示名称。
*/
const char* display_name;
/**
* @property {const char*} desc
* @annotation ["readable"]
* 描述。
*/
const char* desc;
} value_desc_t, prop_desc_t, arg_desc_t, ret_desc_t;
/**
* @class value_desc_int8_t
* @parent value_desc_t
* 有符号8位整数类型属性描述。
*/
typedef struct _value_desc_int8_t {
value_desc_t value_desc;
/**
* @property {int8_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
int8_t defvalue;
/**
* @property {int8_t} min
* @annotation ["readable"]
* 最小值。
*/
int8_t min;
/**
* @property {int8_t} max
* @annotation ["readable"]
* 最大值。
*/
int8_t max;
/**
* @property {int8_t} step
* @annotation ["readable"]
* 步长。
*/
int8_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_int8_t, prop_desc_int8_t, arg_desc_int8_t;
/**
* @class value_desc_uint8_t
* @parent value_desc_t
* 无符号8位整数类型属性描述。
*/
typedef struct _value_desc_uint8_t {
value_desc_t value_desc;
/**
* @property {uint8_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
uint8_t defvalue;
/**
* @property {uint8_t} min
* @annotation ["readable"]
* 最小值。
*/
uint8_t min;
/**
* @property {uint8_t} max
* @annotation ["readable"]
* 最大值。
*/
uint8_t max;
/**
* @property {uint8_t} step
* @annotation ["readable"]
* 步长。
*/
uint8_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_uint8_t, prop_desc_uint8_t, arg_desc_uint8_t;
/**
* @class value_desc_int16_t
* @parent value_desc_t
* 有符号16位整数类型属性描述。
*/
typedef struct _value_desc_int16_t {
value_desc_t value_desc;
/**
* @property {int16_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
int16_t defvalue;
/**
* @property {int16_t} min
* @annotation ["readable"]
* 最小值。
*/
int16_t min;
/**
* @property {int16_t} max
* @annotation ["readable"]
* 最大值。
*/
int16_t max;
/**
* @property {int16_t} step
* @annotation ["readable"]
* 步长。
*/
int16_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_int16_t, prop_desc_int16_t, arg_desc_int16_t;
/**
* @class value_desc_uint16_t
* @parent value_desc_t
* 无符号16位整数类型属性描述。
*/
typedef struct _value_desc_uint16_t {
value_desc_t value_desc;
/**
* @property {uint16_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
uint16_t defvalue;
/**
* @property {uint16_t} min
* @annotation ["readable"]
* 最小值。
*/
uint16_t min;
/**
* @property {uint16_t} max
* @annotation ["readable"]
* 最大值。
*/
uint16_t max;
/**
* @property {uint16_t} step
* @annotation ["readable"]
* 步长。
*/
uint16_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_uint16_t, prop_desc_uint16_t, arg_desc_uint16_t;
/**
* @class value_desc_int32_t
* @parent value_desc_t
* 有符号32位整数类型属性描述。
*/
typedef struct _value_desc_int32_t {
value_desc_t value_desc;
/**
* @property {int32_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
int32_t defvalue;
/**
* @property {int32_t} min
* @annotation ["readable"]
* 最小值。
*/
int32_t min;
/**
* @property {int32_t} max
* @annotation ["readable"]
* 最大值。
*/
int32_t max;
/**
* @property {int32_t} step
* @annotation ["readable"]
* 步长。
*/
int32_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_int32_t, prop_desc_int32_t, arg_desc_int32_t;
/**
* @class value_desc_uint32_t
* @parent value_desc_t
* 无符号32位整数类型属性描述。
*/
typedef struct _value_desc_uint32_t {
value_desc_t value_desc;
/**
* @property {uint32_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
uint32_t defvalue;
/**
* @property {uint32_t} min
* @annotation ["readable"]
* 最小值。
*/
uint32_t min;
/**
* @property {uint32_t} max
* @annotation ["readable"]
* 最大值。
*/
uint32_t max;
/**
* @property {uint32_t} step
* @annotation ["readable"]
* 步长。
*/
uint32_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_uint32_t, prop_desc_uint32_t, arg_desc_uint32_t;
/**
* @class value_desc_int64_t
* @parent value_desc_t
* 有符号64位整数类型属性描述。
*/
typedef struct _value_desc_int64_t {
value_desc_t value_desc;
/**
* @property {int64_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
int64_t defvalue;
/**
* @property {int64_t} min
* @annotation ["readable"]
* 最小值。
*/
int64_t min;
/**
* @property {int64_t} max
* @annotation ["readable"]
* 最大值。
*/
int64_t max;
/**
* @property {int64_t} step
* @annotation ["readable"]
* 步长。
*/
int64_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_int64_t, prop_desc_int64_t, arg_desc_int64_t;
/**
* @class value_desc_uint64_t
* @parent value_desc_t
* 无符号64位整数类型属性描述。
*/
typedef struct _value_desc_uint64_t {
value_desc_t value_desc;
/**
* @property {uint64_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
uint64_t defvalue;
/**
* @property {uint64_t} min
* @annotation ["readable"]
* 最小值。
*/
uint64_t min;
/**
* @property {uint64_t} max
* @annotation ["readable"]
* 最大值。
*/
uint64_t max;
/**
* @property {uint64_t} step
* @annotation ["readable"]
* 步长。
*/
uint64_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_uint64_t, prop_desc_uint64_t, arg_desc_uint64_t;
/**
* @class value_desc_float_t
* @parent value_desc_t
* 单精度浮点数类型属性描述。
*/
typedef struct _value_desc_float_t {
value_desc_t value_desc;
/**
* @property {float} defvalue
* @annotation ["readable"]
* 缺省值。
*/
float defvalue;
/**
* @property {float} min
* @annotation ["readable"]
* 最小值。
*/
float min;
/**
* @property {float} max
* @annotation ["readable"]
* 最大值。
*/
float max;
/**
* @property {float_t} step
* @annotation ["readable"]
* 步长。
*/
float_t step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_float_t, prop_desc_float_t, arg_desc_float_t;
/**
* @class value_desc_double_t
* @parent value_desc_t
* 单精度浮点数类型属性描述。
*/
typedef struct _value_desc_double_t {
value_desc_t value_desc;
/**
* @property {double} defvalue
* @annotation ["readable"]
* 缺省值。
*/
double defvalue;
/**
* @property {double} min
* @annotation ["readable"]
* 最小值。
*/
double min;
/**
* @property {double} max
* @annotation ["readable"]
* 最大值。
*/
double max;
/**
* @property {double} step
* @annotation ["readable"]
* 步长。
*/
double step;
/**
* @property {const char*} unit
* @annotation ["readable"]
* 单位。
*/
const char* unit;
} value_desc_double_t, prop_desc_double_t, arg_desc_double_t;
/**
* @class value_desc_bool_t
* @parent value_desc_t
* 布尔类型属性描述。
*/
typedef struct _value_desc_bool_t {
value_desc_t value_desc;
/**
* @property {bool_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
bool_t defvalue;
} value_desc_bool_t, prop_desc_bool_t, arg_desc_bool_t;
/**
* @class value_desc_string_t
* @parent value_desc_t
* 字符串类型属性描述。
*/
typedef struct _value_desc_string_t {
value_desc_t value_desc;
/**
* @property {const char*} defvalue
* @annotation ["readable"]
* 缺省值。
*/
const char* defvalue;
/**
* @property {uint32_t} min
* @annotation ["readable"]
* 最小长度。
*/
uint32_t min;
/**
* @property {uint32_t} max
* @annotation ["readable"]
* 最大长度。
*/
uint32_t max;
} value_desc_string_t, prop_desc_string_t, arg_desc_string_t;
/**
* @class value_desc_binary_t
* @parent value_desc_t
* 二进制类型属性描述。
*/
typedef struct _value_desc_binary_t {
value_desc_t value_desc;
/**
* @property {uint32_t} min
* @annotation ["readable"]
* 最小长度。
*/
uint32_t min;
/**
* @property {uint32_t} max
* @annotation ["readable"]
* 最大长度。
*/
uint32_t max;
} value_desc_binary_t, prop_desc_binary_t, arg_desc_binary_t;
/**
* @class value_desc_int_enums_t
* @parent value_desc_t
* 整数枚举类型属性描述。
*/
typedef struct _value_desc_int_enums_t {
value_desc_t value_desc;
/**
* @property {int32_t} defvalue
* @annotation ["readable"]
* 缺省值。
*/
int32_t defvalue;
/**
* @property {const char**} enums
* @annotation ["readable"]
* 枚举值（每一项用英文冒号分隔值和名称）。
*/
const char* enums[];
} value_desc_int_enums_t, prop_desc_int_enums_t, arg_desc_int_enums_t;
/**
* @class value_desc_string_enums_t
*
* 字符串枚举类型属性描述。
*/
typedef struct _value_desc_string_enums_t {
value_desc_t value_desc;
/**
* @property {const char*} defvalue
* @annotation ["readable"]
* 缺省值。
*/
const char* defvalue;
/**
* @property {const char**} enums
* @annotation ["readable"]
* 枚举值。
*/
const char* enums[];
} value_desc_string_enums_t, prop_desc_string_enums_t, arg_desc_string_enums_t;
ret_t value_desc_validate(value_desc_t* schema, value_t* v);
END_C_DECLS
#endif /*TK_VALUE_DESC_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/object_default.c
|
/**
* File: object_default.c
* Author: AWTK Develop Team
* Brief: default object
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY { without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-01-10 Li XianJing <[email protected]> created
*
*/
#include "tkc/mem.h"
#include "tkc/value.h"
#include "tkc/utils.h"
#include "tkc/object_default.h"
static tk_compare_t object_default_get_cmp(object_default_t* o) {
if (o->name_case_insensitive) {
return (tk_compare_t)named_value_icompare;
} else {
return (tk_compare_t)named_value_compare;
}
}
static tk_compare_t object_default_get_cmp_by_name(object_default_t* o) {
if (o->name_case_insensitive) {
return (tk_compare_t)named_value_icompare_by_name;
} else {
return (tk_compare_t)named_value_compare_by_name;
}
}
static int32_t object_default_find_prop_index_by_name(tk_object_t* obj, const char* name) {
int32_t ret = -1;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL && name != NULL, -1);
if (*name == '[' && tk_isdigit(name[1]) && tk_str_end_with(name, "]")) {
ret = tk_atoi(name + 1);
return_value_if_fail(ret < o->props.size, -1);
} else {
ret = darray_bsearch_index(&(o->props), object_default_get_cmp_by_name(o), (void*)name);
}
return ret;
}
static value_t* object_default_find_prop_by_name(tk_object_t* obj, const char* name) {
named_value_t* nv = NULL;
object_default_t* o = OBJECT_DEFAULT(obj);
int32_t index = -1;
return_value_if_fail(o != NULL && name != NULL, NULL);
index = object_default_find_prop_index_by_name(obj, name);
if (index >= 0) {
nv = (named_value_t*)darray_get(&o->props, index);
}
return nv != NULL ? &(nv->value) : NULL;
}
ret_t object_default_clear_props(tk_object_t* obj) {
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
return darray_clear(&(o->props));
}
static ret_t object_default_on_destroy(tk_object_t* obj) {
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
return darray_deinit(&(o->props));
}
static int32_t object_default_compare(tk_object_t* obj, tk_object_t* other) {
return_value_if_fail(obj != NULL && other != NULL, -1);
return tk_str_cmp(obj->name, other->name);
}
static ret_t object_default_remove_prop(tk_object_t* obj, const char* name) {
int32_t index = 0;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->props.size > 0 && o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_remove_prop(sub, name);
}
}
index = object_default_find_prop_index_by_name(obj, name);
if (index >= 0) {
return darray_remove_index(&(o->props), index);
} else {
return RET_NOT_FOUND;
}
}
static ret_t value_deep_copy_keep_type(value_t* dst, const value_t* src) {
ret_t ret = RET_OK;
return_value_if_fail(dst != NULL && src != NULL, RET_BAD_PARAMS);
switch (dst->type) {
case VALUE_TYPE_BOOL: {
value_set_bool(dst, value_bool(src));
break;
}
case VALUE_TYPE_INT8: {
value_set_int8(dst, value_int8(src));
break;
}
case VALUE_TYPE_UINT8: {
value_set_uint8(dst, value_uint8(src));
break;
}
case VALUE_TYPE_INT16: {
value_set_int16(dst, value_int16(src));
break;
}
case VALUE_TYPE_UINT16: {
value_set_uint16(dst, value_uint16(src));
break;
}
case VALUE_TYPE_INT32: {
value_set_int32(dst, value_int32(src));
break;
}
case VALUE_TYPE_UINT32: {
value_set_uint32(dst, value_uint32(src));
break;
}
case VALUE_TYPE_INT64: {
value_set_int64(dst, value_int64(src));
break;
}
case VALUE_TYPE_UINT64: {
value_set_uint64(dst, value_uint64(src));
break;
}
case VALUE_TYPE_FLOAT: {
value_set_float(dst, value_float(src));
break;
}
case VALUE_TYPE_DOUBLE: {
value_set_double(dst, value_double(src));
break;
}
case VALUE_TYPE_STRING: {
value_reset(dst);
value_dup_str(dst, value_str(src));
break;
}
default: {
if (dst->type == src->type) {
value_reset(dst);
value_deep_copy(dst, src);
} else {
ret = RET_FAIL;
log_debug("not support type:%d\n", dst->type);
}
break;
}
}
return ret;
}
static ret_t object_default_set_prop(tk_object_t* obj, const char* name, const value_t* v) {
value_t* vv = NULL;
ret_t ret = RET_NOT_FOUND;
object_default_t* o = OBJECT_DEFAULT(obj);
ENSURE(o);
if (o->props.size > 0 && o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_set_prop(sub, name, v);
}
}
vv = object_default_find_prop_by_name(obj, name);
if (vv != NULL) {
if (o->keep_prop_type) {
ret = value_deep_copy_keep_type(vv, v);
} else {
value_reset(vv);
ret = value_deep_copy(vv, v);
}
} else {
named_value_t* nv = named_value_create_ex(name, v);
return_value_if_fail(nv != NULL, RET_OOM);
ret = darray_sorted_insert(&(o->props), nv, object_default_get_cmp(o), FALSE);
if (ret != RET_OK) {
named_value_destroy(nv);
}
}
return ret;
}
static ret_t object_default_get_prop(tk_object_t* obj, const char* name, value_t* v) {
ret_t ret = RET_NOT_FOUND;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (tk_str_eq(name, TK_OBJECT_PROP_SIZE)) {
value_set_uint32(v, o->props.size);
return RET_OK;
}
if (o->props.size > 0 && o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_get_prop(sub, name, v);
}
}
if (o->props.size > 0) {
const value_t* vv = object_default_find_prop_by_name(obj, name);
if (vv != NULL) {
ret = value_copy(v, vv);
} else {
ret = RET_NOT_FOUND;
}
}
return ret;
}
static bool_t object_default_can_exec(tk_object_t* obj, const char* name, const char* args) {
bool_t ret = FALSE;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_can_exec(sub, name, args);
}
}
return ret;
}
static ret_t object_default_exec(tk_object_t* obj, const char* name, const char* args) {
ret_t ret = RET_NOT_FOUND;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
if (o->enable_path) {
tk_object_t* sub = tk_object_get_child_object(obj, name, &name);
if (sub != NULL) {
return tk_object_exec(sub, name, args);
}
}
return ret;
}
static ret_t object_default_foreach_prop(tk_object_t* obj, tk_visit_t on_prop, void* ctx) {
ret_t ret = RET_OK;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL && on_prop != NULL, RET_BAD_PARAMS);
if (o->props.size > 0) {
uint32_t i = 0;
for (i = 0; i < o->props.size; i++) {
named_value_t* iter = (named_value_t*)(o->props.elms[i]);
ret = on_prop(ctx, iter);
if (ret == RET_REMOVE) {
named_value_destroy(iter);
o->props.elms[i] = NULL;
} else if (ret != RET_OK) {
break;
}
}
darray_remove_all(&(o->props), pointer_compare, NULL);
}
return ret;
}
value_t* object_default_find_prop(tk_object_t* obj, tk_compare_t cmp, const void* data) {
named_value_t* nv = NULL;
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL && cmp != NULL, NULL);
nv = (named_value_t*)darray_find_ex(&(o->props), cmp, (void*)data);
return nv != NULL ? &(nv->value) : NULL;
}
tk_object_t* object_default_clone(object_default_t* o) {
uint32_t i = 0;
tk_object_t* dup = NULL;
object_default_t* dupo = NULL;
return_value_if_fail(o != NULL, NULL);
dup = object_default_create();
return_value_if_fail(dup != NULL, NULL);
dupo = OBJECT_DEFAULT(dup);
dupo->enable_path = o->enable_path;
dupo->keep_prop_type = o->keep_prop_type;
dupo->name_case_insensitive = o->name_case_insensitive;
for (i = 0; i < o->props.size; i++) {
named_value_t* iter = (named_value_t*)(o->props.elms[i]);
named_value_t* nv = named_value_create_ex(iter->name, &(iter->value));
if (darray_push(&(dupo->props), nv) != RET_OK) {
named_value_destroy(nv);
break;
}
}
return dup;
}
static const object_vtable_t s_object_default_vtable = {
.type = OBJECT_DEFAULT_TYPE,
.desc = OBJECT_DEFAULT_TYPE,
.size = sizeof(object_default_t),
.is_collection = FALSE,
.on_destroy = object_default_on_destroy,
.clone = (tk_object_clone_t)object_default_clone,
.compare = object_default_compare,
.get_prop = object_default_get_prop,
.set_prop = object_default_set_prop,
.can_exec = object_default_can_exec,
.exec = object_default_exec,
.remove_prop = object_default_remove_prop,
.foreach_prop = object_default_foreach_prop,
.clear_props = object_default_clear_props,
.find_prop = object_default_find_prop,
};
tk_object_t* object_default_create_ex(bool_t enable_path) {
tk_object_t* obj = tk_object_create(&s_object_default_vtable);
object_default_t* o = OBJECT_DEFAULT(obj);
ENSURE(o);
return_value_if_fail(obj != NULL, NULL);
o->enable_path = enable_path;
darray_init(&(o->props), 5, (tk_destroy_t)named_value_destroy, (tk_compare_t)named_value_compare);
return obj;
}
tk_object_t* object_default_create(void) {
return object_default_create_ex(TRUE);
}
ret_t object_default_set_keep_prop_type(tk_object_t* obj, bool_t keep_prop_type) {
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
o->keep_prop_type = keep_prop_type;
return RET_OK;
}
ret_t object_default_set_name_case_insensitive(tk_object_t* obj, bool_t name_case_insensitive) {
object_default_t* o = OBJECT_DEFAULT(obj);
return_value_if_fail(o != NULL, RET_BAD_PARAMS);
o->name_case_insensitive = name_case_insensitive;
return RET_OK;
}
object_default_t* object_default_cast(tk_object_t* obj) {
return_value_if_fail(obj != NULL && obj->vt == &s_object_default_vtable, NULL);
return (object_default_t*)(obj);
}
ret_t object_default_unref(tk_object_t* obj) {
return tk_object_unref(obj);
}
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/event_source_timer.h
|
/**
* File: event_source_timer.h
* Author: AWTK Develop Team
* Brief: event source timer
*
* Copyright (c) 2019 - 2024 Guangzhou ZHIYUAN Electronics Co.,Ltd.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* License file for more details.
*
*/
/**
* History:
* ================================================================
* 2019-09-30 Li XianJing <[email protected]> created
*
*/
#ifndef TK_EVENT_SOURCE_TIMER_H
#define TK_EVENT_SOURCE_TIMER_H
#include "tkc/event_source.h"
#include "tkc/timer_manager.h"
BEGIN_C_DECLS
struct _event_source_timer_t;
typedef struct _event_source_timer_t event_source_timer_t;
/**
* @class event_source_timer_t
* @parent tk_object_t
*
* timer事件源。
*
*/
struct _event_source_timer_t {
event_source_t event_source;
timer_manager_t* timer_manager;
};
/**
* @method event_source_timer_create
*
* 创建timer事件源。
*
* @param {timer_manager_t*} timer_manager 定时器管理器对象。
*
* @return {event_source_t*} 返回事件源对象。
*
*/
event_source_t* event_source_timer_create(timer_manager_t* timer_manager);
#define EVENT_SOURCE_TIMER(obj) ((event_source_timer_t*)(obj))
END_C_DECLS
#endif /*TK_EVENT_SOURCE_TIMER_H*/
|
0 |
repos/awtk/src
|
repos/awtk/src/tkc/socket_pair.c
|
/* socketpair.c
* Copyright 2007 by Nathan C. Myers <[email protected]>; some rights reserved.
* This code is Free Software. It may be copied freely, in original or
* modified form, subject only to the restrictions that (1) the author is
* relieved from all responsibilities for any use for any purpose, and (2)
* this copyright notice must be retained, unchanged, in its entirety. If
* for any reason the author might be held responsible for any consequences
* of copying or use, license is withheld.
*/
/* Changes:
* 2010-02-25:
* set SO_REUSEADDR option to avoid leaking some windows resource.
* Windows System Error 10049, "Event ID 4226 TCP/IP has reached
* the security limit imposed on the number of concurrent TCP connect
* attempts." Bleah.
* 2007-04-25:
* preserve value of WSAGetLastError() on all error returns.
* 2007-04-22: (Thanks to Matthew Gregan <[email protected]>)
* s/EINVAL/WSAEINVAL/ fix trivial compile failure
* s/socket/WSASocket/ enable creation of sockets suitable as stdin/stdout
* of a child process.
* add argument make_overlapped
*/
#include "tkc/types_def.h"
#ifdef WITH_SOCKET
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <io.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#endif
#ifdef WIN32
/* dumb_socketpair:
* If make_overlapped is nonzero, both sockets created will be usable for
* "overlapped" operations via WSASend etc. If make_overlapped is zero,
* socks[0] (only) will be usable with regular ReadFile etc., and thus
* suitable for use as stdin or stdout of a child process. Note that the
* sockets must be closed with closesocket() regardless.
*/
int dumb_socketpair(int socks[2], int make_overlapped) {
union {
struct sockaddr_in inaddr;
struct sockaddr addr;
} a;
int listener;
int e;
socklen_t addrlen = sizeof(a.inaddr);
DWORD flags = (make_overlapped ? WSA_FLAG_OVERLAPPED : 0);
int reuse = 1;
if (socks == 0) {
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
}
listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listener == INVALID_SOCKET) return SOCKET_ERROR;
memset(&a, 0, sizeof(a));
a.inaddr.sin_family = AF_INET;
a.inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
a.inaddr.sin_port = 0;
socks[0] = socks[1] = INVALID_SOCKET;
do {
if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, (socklen_t)sizeof(reuse)) ==
-1)
break;
if (bind(listener, &a.addr, sizeof(a.inaddr)) == SOCKET_ERROR) break;
if (getsockname(listener, &a.addr, &addrlen) == SOCKET_ERROR) break;
if (listen(listener, 1) == SOCKET_ERROR) break;
socks[0] = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, flags);
if (socks[0] == INVALID_SOCKET) break;
if (connect(socks[0], &a.addr, sizeof(a.inaddr)) == SOCKET_ERROR) break;
socks[1] = accept(listener, NULL, NULL);
if (socks[1] == INVALID_SOCKET) break;
closesocket(listener);
return 0;
} while (0);
e = WSAGetLastError();
closesocket(listener);
closesocket(socks[0]);
closesocket(socks[1]);
WSASetLastError(e);
return SOCKET_ERROR;
}
#else
int dumb_socketpair(int socks[2], int dummy) {
(void)dummy;
return socketpair(AF_LOCAL, SOCK_STREAM, 0, socks);
}
#endif
int tk_socketpair(int socks[2]) {
return dumb_socketpair(socks, 0);
}
#else
int tk_socketpair(int socks[2]) {
socks[0] = -1;
socks[1] = -1;
return -1;
}
#endif /*WITH_SOCKET*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.