/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_bool_t gb_bitmap_biltter_shader_init(gb_bitmap_biltter_ref_t biltter, gb_bitmap_ref_t bitmap, gb_paint_ref_t paint)
{
// check
tb_assert_abort(biltter && bitmap && paint);
// init bitmap
biltter->bitmap = bitmap;
// init pixmap
biltter->pixmap = gb_pixmap(gb_bitmap_pixfmt(bitmap), gb_paint_alpha(paint));
tb_check_return_val(biltter->pixmap, tb_false);
// init btp and row_bytes
biltter->btp = biltter->pixmap->btp;
biltter->row_bytes = gb_bitmap_row_bytes(biltter->bitmap);
// init shader
// TODO
// init operations
// TODO
// trace
tb_trace_noimpl();
// ok
return tb_false;
}
tb_void_t tb_lo_scheduler_io_sleep(tb_lo_scheduler_io_ref_t scheduler_io, tb_long_t interval)
{
#ifndef TB_CONFIG_MICRO_ENABLE
// check
tb_assert_and_check_return(scheduler_io && scheduler_io->poller && scheduler_io->scheduler);
// get the current coroutine
tb_lo_coroutine_t* coroutine = tb_lo_scheduler_running(scheduler_io->scheduler);
tb_assert(coroutine);
// trace
tb_trace_d("coroutine(%p): sleep %ld ms ..", coroutine, interval);
// infinity?
if (interval > 0)
{
// high-precision interval?
if (interval % 1000)
{
// post task to timer
tb_timer_task_post(scheduler_io->timer, interval, tb_false, tb_lo_scheduler_io_timeout, coroutine);
}
// low-precision interval?
else
{
// post task to ltimer (faster)
tb_ltimer_task_post(scheduler_io->ltimer, interval, tb_false, tb_lo_scheduler_io_timeout, coroutine);
}
}
#else
// not impl
tb_trace_noimpl();
#endif
}
tb_char_t* tb_strnirstr(tb_char_t const* s1, tb_size_t n1, tb_char_t const* s2)
{
tb_assert_and_check_return_val(s1, tb_null);
tb_trace_noimpl();
return tb_null;
}
tb_char_t const* tb_addrinfo_name(tb_ipaddr_ref_t addr, tb_char_t* name, tb_size_t maxn)
{
// check
tb_assert_and_check_return_val(addr && name && maxn, tb_null);
#if defined(TB_CONFIG_POSIX_HAVE_GETNAMEINFO)
// load socket address
struct sockaddr_storage saddr;
socklen_t saddrlen = (socklen_t)tb_sockaddr_load(&saddr, addr);
tb_assert_and_check_return_val(saddrlen, tb_null);
// get host name from address
return !getnameinfo((struct sockaddr const*)&saddr, saddrlen, name, maxn, tb_null, 0, NI_NAMEREQD)? name : tb_null;
#elif defined(TB_CONFIG_POSIX_HAVE_GETHOSTBYNAME)
// done
struct hostent* hostaddr = tb_null;
switch (tb_ipaddr_family(addr))
{
case TB_IPADDR_FAMILY_IPV4:
{
// init ip address
struct in_addr ipaddr = {0};
ipaddr.s_addr = tb_ipaddr_ip_is_any(addr)? INADDR_ANY : addr->u.ipv4.u32;
// get host name from address
hostaddr = gethostbyaddr((tb_char_t const*)&ipaddr, sizeof(ipaddr), AF_INET);
}
break;
case TB_IPADDR_FAMILY_IPV6:
{
// init ip address
struct in6_addr ipaddr;
tb_memset(&ipaddr, 0, sizeof(ipaddr));
// save ipv6
if (tb_ipaddr_ip_is_any(addr)) ipaddr = in6addr_any;
else tb_memcpy(ipaddr.s6_addr, addr->u.ipv6.addr.u8, sizeof(ipaddr.s6_addr));
// get host name from address
hostaddr = gethostbyaddr((tb_char_t const*)&ipaddr, sizeof(ipaddr), AF_INET6);
}
break;
default:
break;
}
tb_check_return_val(hostaddr && hostaddr->h_name, tb_null);
// save name
tb_strlcpy(name, hostaddr->h_name, maxn);
// ok?
return name;
#else
tb_trace_noimpl();
return tb_null;
#endif
}
static tb_void_t gb_device_skia_resize(gb_device_impl_t* device, tb_size_t width, tb_size_t height)
{
// check
gb_skia_device_ref_t impl = (gb_skia_device_ref_t)device;
tb_assert_and_check_return(impl && impl->bitmap);
// TODO
tb_trace_noimpl();
}
tb_size_t tb_directory_home(tb_char_t* path, tb_size_t maxn)
{
// check
tb_assert_and_check_return_val(path && maxn, 0);
// trace
tb_trace_noimpl();
return 0;
}
tb_context_from_t tb_context_jump(tb_context_ref_t context, tb_cpointer_t priv)
{
// noimpl
tb_trace_noimpl();
// return emtry context
tb_context_from_t from = {0};
return from;
}
static gb_shader_ref_t gb_device_skia_shader_bitmap(gb_device_impl_t* device, tb_size_t mode, gb_bitmap_ref_t bitmap)
{
// check
gb_skia_device_ref_t impl = (gb_skia_device_ref_t)device;
tb_assert_and_check_return_val(impl, tb_null);
// TODO
tb_trace_noimpl();
return tb_null;
}
static gb_shader_ref_t gb_device_skia_shader_radial(gb_device_impl_t* device, tb_size_t mode, gb_gradient_ref_t gradient, gb_circle_ref_t circle)
{
// check
gb_skia_device_ref_t impl = (gb_skia_device_ref_t)device;
tb_assert_and_check_return_val(impl, tb_null);
// TODO
tb_trace_noimpl();
return tb_null;
}
tb_bool_t tb_addrinfo_addr(tb_char_t const* name, tb_ipaddr_ref_t addr)
{
#ifndef TB_CONFIG_MICRO_ENABLE
// attempt to get address using dns looker
if (tb_ipaddr_family(addr) != TB_IPADDR_FAMILY_IPV6 && tb_dns_looker_done(name, addr))
return tb_true;
#endif
// not implemented
tb_trace_noimpl();
return tb_false;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* interfaces
*/
tb_filter_ref_t tb_filter_init_from_chunked(tb_bool_t dechunked)
{
// done
tb_bool_t ok = tb_false;
tb_filter_chunked_t* filter = tb_null;
do
{
// noimpl for encoding chunked
if (!dechunked)
{
tb_trace_noimpl();
break;
}
// make filter
filter = tb_malloc0_type(tb_filter_chunked_t);
tb_assert_and_check_break(filter);
// init filter
if (!tb_filter_init((tb_filter_t*)filter, TB_FILTER_TYPE_CHUNKED)) break;
filter->base.spak = tb_filter_chunked_spak;
filter->base.clos = tb_filter_chunked_clos;
filter->base.exit = tb_filter_chunked_exit;
// init line
if (!tb_string_init(&filter->line)) break;
// ok
ok = tb_true;
} while (0);
// failed?
if (!ok)
{
// exit filter
tb_filter_exit((tb_filter_ref_t)filter);
filter = tb_null;
}
// ok?
return (tb_filter_ref_t)filter;
}
/* ///////////////////////////////////////////////////////////////////////
* implementation
*/
tb_handle_t g2_context_init(tb_size_t pixfmt, tb_pointer_t data, tb_size_t width, tb_size_t height, tb_size_t lpitch)
{
tb_trace_noimpl();
return tb_null;
}
tb_void_t g2_context_exit(tb_handle_t context)
{
tb_trace_noimpl();
}
tb_long_t tb_charset_utf32_set(tb_static_stream_ref_t sstream, tb_bool_t be, tb_uint32_t ch)
{
tb_trace_noimpl();
return -1;
}
static tb_object_ref_t tb_object_xplist_reader_func_number(tb_object_xplist_reader_t* reader, tb_size_t event)
{
// check
tb_assert_and_check_return_val(reader && reader->reader && event, tb_null);
// empty?
if (event == TB_XML_READER_EVENT_ELEMENT_EMPTY)
return tb_object_number_init_from_uint32(0);
// done
tb_bool_t leave = tb_false;
tb_object_ref_t number = tb_null;
while (!leave && (event = tb_xml_reader_next(reader->reader)))
{
switch (event)
{
case TB_XML_READER_EVENT_ELEMENT_END:
{
// name
tb_char_t const* name = tb_xml_reader_element(reader->reader);
tb_assert_and_check_break_state(name, leave, tb_true);
// is end?
if (!tb_stricmp(name, "integer") || !tb_stricmp(name, "real")) leave = tb_true;
}
break;
case TB_XML_READER_EVENT_TEXT:
{
// text
tb_char_t const* text = tb_xml_reader_text(reader->reader);
tb_assert_and_check_break_state(text, leave, tb_true);
tb_trace_d("number: %s", text);
// has sign? is float?
tb_size_t s = 0;
tb_size_t f = 0;
tb_char_t const* p = text;
for (; *p; p++)
{
if (!s && *p == '-') s = 1;
if (!f && *p == '.') f = 1;
if (s && f) break;
}
// number
#ifdef TB_CONFIG_TYPE_HAVE_FLOAT
if (f) number = tb_object_number_init_from_double(tb_atof(text));
#else
if (f) tb_trace_noimpl();
#endif
else number = s? tb_object_number_init_from_sint64(tb_stoi64(text)) : tb_object_number_init_from_uint64(tb_stou64(text));
tb_assert_and_check_break_state(number, leave, tb_true);
}
break;
default:
break;
}
}
// ok?
return number;
}
tb_bool_t tb_socket_ctrl(tb_socket_ref_t sock, tb_size_t ctrl, ...)
{
tb_trace_noimpl();
return tb_false;
}
tb_size_t tb_wcstombs(tb_char_t* s1, tb_wchar_t const* s2, tb_size_t n)
{
tb_trace_noimpl();
return -1;
}
tb_bool_t tb_socket_kill(tb_socket_ref_t sock, tb_size_t mode)
{
tb_trace_noimpl();
return tb_false;
}
static tb_object_ref_t tb_object_json_reader_func_number(tb_object_json_reader_t* reader, tb_char_t type)
{
// check
tb_assert_and_check_return_val(reader && reader->stream, tb_null);
// init data
tb_static_string_t data;
tb_char_t buff[256];
if (!tb_static_string_init(&data, buff, 256)) return tb_null;
// done
tb_object_ref_t number = tb_null;
do
{
// append character
tb_static_string_chrcat(&data, type);
// walk
tb_bool_t bs = (type == '-')? tb_true : tb_false;
tb_bool_t bf = (type == '.')? tb_true : tb_false;
tb_bool_t failed = tb_false;
while (!failed && tb_stream_left(reader->stream))
{
// need one character
tb_byte_t* p = tb_null;
if (!tb_stream_need(reader->stream, &p, 1) && p)
{
failed = tb_true;
break;
}
// the character
tb_char_t ch = *p;
// is float?
if (!bf && ch == '.') bf = tb_true;
else if (bf && ch == '.')
{
failed = tb_true;
break;
}
// append character
if (tb_isdigit10(ch) || ch == '.' || ch == 'e' || ch == 'E' || ch == '-' || ch == '+')
tb_static_string_chrcat(&data, ch);
else break;
// skip it
tb_stream_skip(reader->stream, 1);
}
// failed?
tb_check_break(!failed);
// check
tb_assert_and_check_break(tb_static_string_size(&data));
// trace
tb_trace_d("number: %s", tb_static_string_cstr(&data));
// init number
#ifdef TB_CONFIG_TYPE_FLOAT
if (bf) number = tb_object_number_init_from_float(tb_stof(tb_static_string_cstr(&data)));
#else
if (bf) tb_trace_noimpl();
#endif
else if (bs)
{
tb_sint64_t value = tb_stoi64(tb_static_string_cstr(&data));
tb_size_t bytes = tb_object_need_bytes(-value);
switch (bytes)
{
case 1: number = tb_object_number_init_from_sint8((tb_sint8_t)value); break;
case 2: number = tb_object_number_init_from_sint16((tb_sint16_t)value); break;
case 4: number = tb_object_number_init_from_sint32((tb_sint32_t)value); break;
case 8: number = tb_object_number_init_from_sint64((tb_sint64_t)value); break;
default: break;
}
}
else
{
tb_uint64_t value = tb_stou64(tb_static_string_cstr(&data));
tb_size_t bytes = tb_object_need_bytes(value);
switch (bytes)
{
case 1: number = tb_object_number_init_from_uint8((tb_uint8_t)value); break;
case 2: number = tb_object_number_init_from_uint16((tb_uint16_t)value); break;
case 4: number = tb_object_number_init_from_uint32((tb_uint32_t)value); break;
case 8: number = tb_object_number_init_from_uint64((tb_uint64_t)value); break;
default: break;
}
}
} while (0);
// exit data
tb_static_string_exit(&data);
// ok?
return number;
}
tb_socket_ref_t tb_socket_accept(tb_socket_ref_t sock, tb_ipaddr_ref_t addr)
{
tb_trace_noimpl();
return tb_null;
}
tb_bool_t tb_socket_local(tb_socket_ref_t sock, tb_ipaddr_ref_t addr)
{
tb_trace_noimpl();
return tb_false;
}
tb_socket_ref_t tb_socket_init(tb_size_t type, tb_size_t family)
{
tb_trace_noimpl();
return tb_null;
}
tb_size_t tb_socket_bind(tb_socket_ref_t sock, tb_ipaddr_ref_t addr)
{
tb_trace_noimpl();
return 0;
}
tb_long_t tb_socket_connect(tb_socket_ref_t sock, tb_ipaddr_ref_t addr)
{
tb_trace_noimpl();
return -1;
}
tb_handle_t g2_context_surface(tb_handle_t context)
{
tb_trace_noimpl();
return tb_null;
}
tb_bool_t tb_socket_exit(tb_socket_ref_t sock)
{
tb_trace_noimpl();
return tb_false;
}
tb_handle_t g2_context_resize(tb_handle_t context, tb_size_t width, tb_size_t height)
{
tb_trace_noimpl();
return tb_null;
}
tb_bool_t tb_sched_yield()
{
tb_trace_noimpl();
return tb_false;
}
tb_bool_t tb_socket_listen(tb_socket_ref_t sock, tb_size_t backlog)
{
tb_trace_noimpl();
return tb_false;
}
tb_bool_t tb_socket_pair(tb_size_t type, tb_socket_ref_t pair[2])
{
tb_trace_noimpl();
return tb_false;
}
