Cppcheck report - GATE C/C++ Framework: gate/system/terminals.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger                                  |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/system/terminals.h"
#include "gate/platforms.h"
#include "gate/atomics.h"
#include "gate/results.h"
#include "gate/debugging.h"
#include "gate/inputs.h"

#if defined(GATE_SYS_WIN) && !defined(GATE_SYS_WIN16)
#	define GATE_SYSTEM_TERMINALS_WINAPI 1
#elif defined(GATE_SYS_POSIX)
#	define GATE_SYSTEM_TERMINALS_POSIX 1
#elif defined(GATE_SYS_DOS)
#	define GATE_SYSTEM_TERMINALS_DOS 1
#elif defined(GATE_SYS_EFI)
#	define GATE_SYSTEM_TERMINALS_EFI 1
#else
#	define GATE_SYSTEM_TERMINALS_NOIMPL 1
#endif


/* generic definitions and implementations */

static void				gate_terminal_console_release(void* thisptr);
static int				gate_terminal_console_retain(void* thisptr);
static char const* gate_terminal_console_get_interface_name(void* thisptr);

static gate_result_t	gate_terminal_console_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned);
static gate_result_t	gate_terminal_console_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned);
static gate_result_t	gate_terminal_console_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written);
static gate_result_t	gate_terminal_console_flush(void* thisptr);

static gate_result_t	gate_terminal_console_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* resource);

static gate_result_t	gate_terminal_console_await_char(void* thisptr, gate_uint32_t timeout_ms);
static gate_result_t	gate_terminal_console_read_char(void* thisptr, gate_char32_t* ptr_char);
static gate_result_t	gate_terminal_console_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written);
static gate_result_t	gate_terminal_console_flush_err(void* thisptr);

static gate_result_t	gate_terminal_console_get_type(void* thisptr);
static gate_result_t	gate_terminal_console_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height);
static gate_result_t	gate_terminal_console_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y);
static gate_result_t	gate_terminal_console_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y);
static gate_result_t	gate_terminal_console_set_cursor_mode(void* thisptr, gate_uint16_t mode);
static gate_result_t	gate_terminal_console_clear(void* thisptr);

static gate_result_t	gate_terminal_console_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code);
static gate_result_t	gate_terminal_console_set_text_color(void* thisptr, gate_uint8_t color_code);

static gate_result_t	gate_terminal_console_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code);
static gate_result_t	gate_terminal_console_set_back_color(void* thisptr, gate_uint8_t color_code);


static GATE_INTERFACE_VTBL(gate_terminal) gate_terminal_console_vtbl;
static void gate_init_terminal_console_vtbl()
{
    if (!gate_terminal_console_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_terminal) const local_vtbl =
        {
            &gate_terminal_console_get_interface_name,
            &gate_terminal_console_release,
            &gate_terminal_console_retain,

            &gate_terminal_console_read,
            &gate_terminal_console_peek,
            &gate_terminal_console_write,
            &gate_terminal_console_flush,

            &gate_terminal_console_get_resource,

            &gate_terminal_console_await_char,
            &gate_terminal_console_read_char,
            &gate_terminal_console_write_err,
            &gate_terminal_console_flush_err,

            &gate_terminal_console_get_type,
            &gate_terminal_console_get_size,
            &gate_terminal_console_get_cursor_pos,
            &gate_terminal_console_set_cursor_pos,
            &gate_terminal_console_set_cursor_mode,
            &gate_terminal_console_clear,

            &gate_terminal_console_get_text_color,
            &gate_terminal_console_set_text_color,

            &gate_terminal_console_get_back_color,
            &gate_terminal_console_set_back_color
        };
        gate_terminal_console_vtbl = local_vtbl;
    }
}



static gate_result_t gate_terminal_vt100_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    char buffer[128];
    static gate_size_t len = sizeof(buffer) - 1;
    gate_size_t used = 0;
    ++x;
    ++y;

    used += gate_str_print_text(&buffer[used], len - used, "\x1b[", 2);
    used += gate_str_print_uint16(&buffer[used], len - used, y);
    used += gate_str_print_text(&buffer[used], len - used, ";", 1);
    used += gate_str_print_uint16(&buffer[used], len - used, x);
    used += gate_str_print_text(&buffer[used], len - used, "H", 1);

    return gate_terminal_console_write(thisptr, buffer, used, NULL);
}
static gate_result_t gate_terminal_vt100_clear(void* thisptr)
{
#define cmd_clear "\x1b[0;40;37m\x1b[1;1H\x1b[2J"
    gate_size_t const cmd_clear_size = gate_str_length(cmd_clear);

    return gate_terminal_console_write(thisptr, cmd_clear, cmd_clear_size, NULL);
}

static gate_result_t gate_terminal_get_text_color_code(int color_type, int* color_code, int* attr_code)
{
    switch (color_type)
    {
    case GATE_TERMINAL_COLOR_BLACK:			*color_code = 30; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_BLUE:			*color_code = 34; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_GREEN:			*color_code = 32; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_CYAN:			*color_code = 36; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_RED:			*color_code = 31; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_MAGENTA:		*color_code = 35; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_ORANGE:		*color_code = 33; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_WHITE:			*color_code = 37; *attr_code = 0; break;
    case GATE_TERMINAL_COLOR_GRAY:			*color_code = 30; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_LIGHTBLUE:		*color_code = 34; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_LIGHTGREEN:	*color_code = 32; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_LIGHTCYAN:		*color_code = 36; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_LIGHTRED:		*color_code = 31; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_LIGHTMAGENTA:	*color_code = 35; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_YELLOW:		*color_code = 33; *attr_code = 1; break;
    case GATE_TERMINAL_COLOR_LIGHTWHITE:	*color_code = 37; *attr_code = 1; break;
    default:	return false;
    }
    return true;
}

static gate_result_t gate_terminal_get_back_color_code(int color_type, int* color_code)
{
    switch (color_type)
    {
    case GATE_TERMINAL_COLOR_BLACK:			*color_code = 40; break;
    case GATE_TERMINAL_COLOR_BLUE:			*color_code = 44; break;
    case GATE_TERMINAL_COLOR_GREEN:			*color_code = 42; break;
    case GATE_TERMINAL_COLOR_CYAN:			*color_code = 46; break;
    case GATE_TERMINAL_COLOR_RED:			*color_code = 41; break;
    case GATE_TERMINAL_COLOR_MAGENTA:		*color_code = 45; break;
    case GATE_TERMINAL_COLOR_ORANGE:		*color_code = 43; break;
    case GATE_TERMINAL_COLOR_WHITE:			*color_code = 47; break;
    case GATE_TERMINAL_COLOR_GRAY:			*color_code = 40; break;
    case GATE_TERMINAL_COLOR_LIGHTBLUE:		*color_code = 44; break;
    case GATE_TERMINAL_COLOR_LIGHTGREEN:	*color_code = 42; break;
    case GATE_TERMINAL_COLOR_LIGHTCYAN:		*color_code = 46; break;
    case GATE_TERMINAL_COLOR_LIGHTRED:		*color_code = 41; break;
    case GATE_TERMINAL_COLOR_LIGHTMAGENTA:	*color_code = 45; break;
    case GATE_TERMINAL_COLOR_YELLOW:		*color_code = 43; break;
    case GATE_TERMINAL_COLOR_LIGHTWHITE:	*color_code = 47; break;
    default:	return false;
    }
    return true;
}

static gate_result_t gate_terminal_console_set_color(void* thisptr, int attr, int textcolor, int backcolor)
{
    char buffer[128];
    gate_size_t const len = sizeof(buffer);
    gate_size_t used = 0;
    used += gate_str_print_text(&buffer[used], len - used, "\x1b[", 2);
    used += gate_str_print_int32(&buffer[used], len - used, attr);
    used += gate_str_print_text(&buffer[used], len - used, ";", 1);
    used += gate_str_print_int32(&buffer[used], len - used, textcolor);
    used += gate_str_print_text(&buffer[used], len - used, ";", 1);
    used += gate_str_print_int32(&buffer[used], len - used, backcolor);
    used += gate_str_print_text(&buffer[used], len - used, "m", 1);

    return gate_terminal_console_write(thisptr, buffer, used, NULL);
}

static gate_result_t gate_terminal_vt100_set_text_color(void* thisptr, gate_uint8_t text_color_code)
{
    int attr;
    gate_uint8_t back_color_code = 0;
    int textcolor;
    int backcolor;
    gate_terminal_console_get_back_color(thisptr, &back_color_code);
    gate_terminal_get_text_color_code(text_color_code, &textcolor, &attr);
    gate_terminal_get_back_color_code(back_color_code, &backcolor);
    return gate_terminal_console_set_color(thisptr, attr, textcolor, backcolor);
}
static gate_result_t gate_terminal_vt100_set_back_color(void* thisptr, gate_uint8_t back_color_code)
{
    int attr;
    int textcolor;
    int backcolor;
    gate_uint8_t text_color_code;
    gate_terminal_console_get_text_color(thisptr, &text_color_code);
    gate_terminal_get_text_color_code(text_color_code, &textcolor, &attr);
    gate_terminal_get_back_color_code(back_color_code, &backcolor);
    return gate_terminal_console_set_color(thisptr, attr, textcolor, backcolor);
}

static gate_result_t gate_terminal_vt100_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_width);
    GATE_UNUSED_ARG(ptr_height);
    /*TODO*/
    return GATE_RESULT_NOTSUPPORTED;
}

static gate_result_t gate_terminal_vt100_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_x);
    GATE_UNUSED_ARG(ptr_y);
    /*TODO*/
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t gate_terminal_vt100_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_color_code);
    /*TODO*/
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t gate_terminal_vt100_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_color_code);
    /*TODO*/
    return GATE_RESULT_NOTSUPPORTED;
}

static gate_result_t gate_terminal_vt100_enable_cursor(void* thisptr, gate_bool_t enabled)
{
    static char const* vt100_enable_cursor_code = "\x1b[25h";
    static char const* vt100_disable_cursor_code = "\x1b[25l";
    return gate_terminal_console_write(
        thisptr,
        (enabled ? vt100_enable_cursor_code : vt100_disable_cursor_code),
        5,
        NULL);
}




typedef struct vterm_cell_class
{
    gate_char16_t	character;
    gate_uint8_t	color;
    gate_uint8_t	flags;
} vterm_cell_t;

typedef struct vterm_class
{
    GATE_INTERFACE_VTBL(gate_terminal) const* vtbl;

    gate_atomic_int_t ref_counter;

    gate_uint16_t	cols;
    gate_uint16_t	rows;
    gate_enumint_t	flags;
    gate_uint16_t	cursor_x;
    gate_uint16_t	cursor_y;
    gate_uint8_t	cursor_color;
    gate_terminal_read_char_t	reader;
    void* reader_param;
    gate_terminal_write_char_t	writer;
    void* writer_param;
    gate_char16_t				input_buffer[4];
    gate_uint32_t				default_read_timeout_ms;

    vterm_cell_t** lines;


} vterm_t;

static char const* vterm_get_interface_name(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_INTERFACE_NAME_TERMINAL;
}

static void vterm_destroy(vterm_t* self)
{
    gate_mem_dealloc(self);
}

static void vterm_release(void* thisptr)
{
    vterm_t* self = (vterm_t*)thisptr;
    if (gate_atomic_int_dec(&self->ref_counter) == 0)
    {
        vterm_destroy(self);
    }
}
static int vterm_retain(void* thisptr)
{
    vterm_t* self = (vterm_t*)thisptr;
    return gate_atomic_int_inc(&self->ref_counter);
}

static gate_result_t vterm_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    vterm_t* self = (vterm_t*)thisptr;
    GATE_UNUSED_ARG(self);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(returned);
    return GATE_RESULT_NOTIMPLEMENTED;
}
static gate_result_t vterm_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    vterm_t* self = (vterm_t*)thisptr;
    GATE_UNUSED_ARG(self);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(returned);
    return GATE_RESULT_NOTIMPLEMENTED;
}
static void vterm_scroll_line(vterm_t* self)
{
    gate_size_t line_len = self->cols * sizeof(vterm_cell_t);
    gate_size_t move_len = line_len * self->rows - 1;
    vterm_cell_t* first_line = self->lines[0];
    vterm_cell_t* second_line = self->lines[1];
    vterm_cell_t* last_line = self->lines[self->rows - 1];
    gate_size_t ndx;
    gate_mem_move(first_line, second_line, move_len);
    for (ndx = 0; ndx != self->cols; ++ndx)
    {
        last_line[ndx].character = ' ';
        last_line[ndx].color = self->cursor_color;

    }
}
static void vterm_newline(vterm_t* self)
{
    self->cursor_x = 0;
    ++self->cursor_y;
    if (self->cursor_y >= self->rows)
    {
        self->cursor_y = self->rows - 1;
        vterm_scroll_line(self);
    }
}

static void vterm_set_char(vterm_t* self, gate_char16_t chr)
{
    vterm_cell_t* ptr_cell = &self->lines[self->cursor_y][self->cursor_x];
    ptr_cell->character = chr;
    ptr_cell->color = self->cursor_color;
}
static void vterm_write_char(vterm_t* self, gate_char16_t chr)
{
    switch (chr)
    {
    case 8:		/* backspace */
    {
        if (self->cursor_x > 0)
        {
            vterm_set_char(self, ' ');
            --self->cursor_x;
        }
        break;
    }
    case 9:		/* tab */
    {
        self->cursor_x += 4;
        self->cursor_x -= (self->cursor_x % 4);
        if (self->cursor_x >= self->cols)
        {
            vterm_newline(self);
        }
        break;
    }
    case 10:	/* newline */
    {
        vterm_newline(self);
        break;
    }
    case 13:	/* carriage return */
    {
        self->cursor_x = 0;
        break;
    }
    default:
    {
        vterm_set_char(self, chr);
        ++self->cursor_x;
        if (self->cursor_x >= self->cols)
        {
            vterm_newline(self);
        }
        break;
    }
    }
}
static gate_result_t vterm_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    vterm_t* self = (vterm_t*)thisptr;
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t processed = 0;
    gate_char16_t chr16;

    while (bufferlength > 0)
    {
        chr16 = *buffer;
        vterm_write_char(self, chr16);
        if (self->writer)
        {
            self->writer(chr16, self->writer_param);
        }

        --bufferlength;
        ++buffer;
        ++processed;
    }
    if (written)
    {
        *written = processed;
    }
    return ret;
}
static gate_result_t vterm_flush(void* thisptr)
{
    vterm_t* self = (vterm_t*)thisptr;
    GATE_UNUSED_ARG(self);
    return GATE_RESULT_OK;
}

static gate_result_t vterm_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* resource)
{
    vterm_t* self = (vterm_t*)thisptr;
    GATE_UNUSED_ARG(self);
    GATE_UNUSED_ARG(resource_type);
    GATE_UNUSED_ARG(resource);
    return GATE_RESULT_NOTIMPLEMENTED;
}

static gate_result_t vterm_await_char(void* thisptr, gate_uint32_t timeout_ms)
{
    vterm_t* self = (vterm_t*)thisptr;
    gate_result_t ret = GATE_RESULT_NOTAVAILABLE;
    gate_char16_t chr16;

    if (self->input_buffer[0])
    {
        /* we have something in the input buffer */
        ret = GATE_RESULT_OK;
    }
    else
    {
        if (self->reader)
        {
            ret = self->reader(&chr16, timeout_ms, self->reader_param);
            if (GATE_SUCCEEDED(ret))
            {
                self->input_buffer[0] = chr16;
            }
        }
    }
    return ret;
}
static gate_result_t vterm_read_char(void* thisptr, gate_char32_t* ptr_char)
{
    vterm_t* self = (vterm_t*)thisptr;
    gate_result_t ret = GATE_RESULT_NOTAVAILABLE;
    do
    {
        ret = vterm_await_char(self, self->default_read_timeout_ms);
        GATE_BREAK_IF_FAILED(ret);

        if (self->input_buffer[0])
        {
            if (ptr_char)
            {
                *ptr_char = self->input_buffer[0];
            }
            self->input_buffer[0] = 0;
            ret = GATE_RESULT_OK;
        }
        else
        {
            ret = GATE_RESULT_NOTAVAILABLE;
        }
    } while (0);

    return ret;
}
static gate_result_t vterm_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    return vterm_write(thisptr, buffer, bufferlength, written);
}
static gate_result_t vterm_flush_err(void* thisptr)
{
    return vterm_flush(thisptr);
}

static gate_enumint_t vterm_get_type(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_TERMINAL_TYPE_VT100;
}

static gate_result_t vterm_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    vterm_t* self = (vterm_t*)thisptr;
    if (ptr_width)
    {
        *ptr_width = self->cols;
    }
    if (ptr_height)
    {
        *ptr_height = self->rows;
    }
    return GATE_RESULT_OK;
}
static gate_result_t vterm_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    vterm_t* self = (vterm_t*)thisptr;
    if (ptr_x)
    {
        *ptr_x = self->cursor_x;
    }
    if (ptr_y)
    {
        *ptr_y = self->cursor_y;
    }
    return GATE_RESULT_OK;
}
static gate_result_t vterm_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    vterm_t* self = (vterm_t*)thisptr;
    if (x >= self->cols)
    {
        x = self->cols - 1;
    }
    if (y >= self->rows)
    {
        y = self->rows - 1;
    }
    self->cursor_x = x;
    self->cursor_y = y;
    return GATE_RESULT_OK;
}
static gate_result_t vterm_set_cursor_mode(void* thisptr, gate_uint16_t mode)
{
    vterm_t* self = (vterm_t*)thisptr;
    GATE_UNUSED_ARG(self);
    GATE_UNUSED_ARG(mode);
    return GATE_RESULT_NOTIMPLEMENTED;
}
static gate_result_t vterm_clear(void* thisptr)
{
    vterm_t* self = (vterm_t*)thisptr;
    unsigned x, y;
    vterm_cell_t* ptr_cell;
<--- The scope of the variable 'ptr_cell' can be reduced. [+]
The scope of the variable 'ptr_cell' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    for (y = 0; y != self->rows; ++y)
    {
        ptr_cell = self->lines[y];
        for (x = 0; x != self->cols; ++x)
        {
            ptr_cell->character = ' ';
            ptr_cell->color = self->cursor_color;
            ptr_cell->flags = 0;
            ++ptr_cell;
        }
    }

    return GATE_RESULT_OK;
}

static gate_result_t vterm_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    vterm_t* self = (vterm_t*)thisptr;
    if (ptr_color_code)
    {
        *ptr_color_code = self->cursor_color & 0x0f;
    }
    return GATE_RESULT_OK;
}
static gate_result_t vterm_set_text_color(void* thisptr, gate_uint8_t color_code)
{
    vterm_t* self = (vterm_t*)thisptr;
    self->cursor_color = (self->cursor_color & 0xf0) | (color_code & 0xf);
    return GATE_RESULT_OK;
}

static gate_result_t vterm_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    vterm_t* self = (vterm_t*)thisptr;
    if (ptr_color_code)
    {
        *ptr_color_code = ((self->cursor_color & 0xf0) >> 4);
    }
    return GATE_RESULT_OK;
}
static gate_result_t vterm_set_back_color(void* thisptr, gate_uint8_t color_code)
{
    vterm_t* self = (vterm_t*)thisptr;
    self->cursor_color = (self->cursor_color & 0x0f) | ((color_code & 0xf) << 4);
    return GATE_RESULT_OK;
}


static GATE_INTERFACE_VTBL(gate_terminal) vterm_vtbl;

static void init_vterm_vtbl()
{
    if (vterm_vtbl.get_interface_name == NULL)
    {
        GATE_INTERFACE_VTBL(gate_terminal) const vtbl = {
            &vterm_get_interface_name,
            &vterm_release,
            &vterm_retain,
            &vterm_read,
            &vterm_peek,
            &vterm_write,
            &vterm_flush,
            &vterm_get_resource,
            &vterm_await_char,
            &vterm_read_char,
            &vterm_write_err,
            &vterm_flush_err,
            &vterm_get_type,
            &vterm_get_size,
            &vterm_get_cursor_pos,
            &vterm_set_cursor_pos,
            &vterm_set_cursor_mode,
            &vterm_clear,
            &vterm_get_text_color,
            &vterm_set_text_color,
            &vterm_get_back_color,
            &vterm_set_back_color
        };
        vterm_vtbl = vtbl;
    }
}

gate_terminal_t* gate_terminal_virtual_create(gate_uint16_t columns, gate_uint16_t rows, gate_enumint_t flags,
    gate_terminal_read_char_t read_callback, void* read_param,
    gate_terminal_write_char_t write_callback, void* write_param)
{
    gate_terminal_t* ret = NULL;
    vterm_t* ptr = NULL;
    gate_size_t line_length;
    gate_size_t additional_size;
    char* first_line_ptr;
    char* first_cell_ptr;
<--- The scope of the variable 'first_cell_ptr' can be reduced. [+]
The scope of the variable 'first_cell_ptr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_size_t ndx;

    do
    {
        if (columns == 0) columns = 80;
        if (rows == 0) rows = 25;

        line_length = sizeof(vterm_cell_t) * columns;
        additional_size = rows * line_length + (rows * sizeof(vterm_cell_t*));

        ptr = (vterm_t*)gate_mem_alloc(sizeof(vterm_t) + additional_size);
        if (!ptr)
        {
            break;
        }
        gate_mem_clear(ptr, sizeof(vterm_t) + additional_size);
        init_vterm_vtbl();
        ptr->vtbl = &vterm_vtbl;
        gate_atomic_int_init(&ptr->ref_counter, 1);
        ptr->cols = columns;
        ptr->rows = rows;
        ptr->flags = flags;
        ptr->cursor_x = 0;
        ptr->cursor_y = 0;
        ptr->cursor_color = 0x07;
        ptr->reader = read_callback;
        ptr->reader_param = read_param;
        ptr->writer = write_callback;
        ptr->writer_param = write_param;
        ptr->default_read_timeout_ms = 4000;

        first_line_ptr = (char*)ptr + sizeof(vterm_t);
        first_cell_ptr = first_line_ptr + (sizeof(vterm_cell_t*) * rows);

        ptr->lines = (vterm_cell_t**)first_line_ptr;

        for (ndx = 0; ndx != rows; ++ndx)
        {
            ptr->lines[ndx] = (vterm_cell_t*)(first_cell_ptr + line_length * ndx);
        }

        ret = (gate_terminal_t*)ptr;
        ptr = NULL;

    } while (0);

    if (ptr)
    {
        vterm_destroy(ptr);
    }

    return ret;
}





#if defined(GATE_SYSTEM_TERMINALS_WINAPI)

#include "gate/times.h"

#if defined(GATE_SYS_WINCE)
#	include <stdio.h>
#endif

typedef struct gate_terminal_console_impl_class
{
    GATE_INTERFACE_VTBL(gate_terminal) const* vtbl;

    gate_atomic_int_t	ref_counter;
    gate_uint32_t		flags;

    HANDLE con_input;
    HANDLE con_output;
    HANDLE con_error;

    gate_char32_t	char_buffer[16];
    gate_size_t		char_buffer_used;

} gate_terminal_console_impl_t;

static void close_file_handle(HANDLE handle)
{
    if ((handle != NULL) && (handle != INVALID_HANDLE_VALUE))
    {
        CloseHandle(handle);
    }
}

#ifndef GATE_SYS_WINCE

#ifndef ENABLE_VIRTUAL_TERMINAL_INPUT
#define ENABLE_VIRTUAL_TERMINAL_INPUT       0x0200
#endif

#ifndef ENABLE_QUICK_EDIT_MODE
#define ENABLE_QUICK_EDIT_MODE 0x0040
#endif

#ifndef ENABLE_INSERT_MODE
#define ENABLE_INSERT_MODE 0x0020
#endif 

static BOOL gate_terminal_console_set_input_flags(HANDLE handle, gate_uint32_t flags)
{
    BOOL ret = FALSE;
    DWORD dwMode = 0;
    if (!GetConsoleMode(handle, &dwMode))
    {
        return FALSE;
    }

    GATE_FLAG_SET(dwMode, ENABLE_WINDOW_INPUT, true);
    GATE_FLAG_SET(dwMode, ENABLE_QUICK_EDIT_MODE, false);
    GATE_FLAG_SET(dwMode, ENABLE_PROCESSED_INPUT, !GATE_FLAG_ENABLED(flags, GATE_TERMINAL_FLAG_GETCTRL));
    GATE_FLAG_SET(dwMode, ENABLE_MOUSE_INPUT, true);
    GATE_FLAG_SET(dwMode, ENABLE_INSERT_MODE, false);
    GATE_FLAG_SET(dwMode, ENABLE_ECHO_INPUT, GATE_FLAG_ENABLED(flags, GATE_TERMINAL_FLAG_ECHO));
    ret = SetConsoleMode(handle, dwMode);
    if (GATE_SUCCEEDED(ret))
    {
        // VT100 support is optional (not available before Windows 10)
        GATE_FLAG_SET(dwMode, ENABLE_VIRTUAL_TERMINAL_INPUT, GATE_FLAG_ENABLED(flags, GATE_TERMINAL_FLAG_VT100));
    }
    return ret;
}

#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING  0x0004
#endif

static BOOL gate_terminal_console_set_output_flags(HANDLE handle, gate_uint32_t flags)
{
    BOOL ret = FALSE;
    DWORD dwMode = 0;
    if (!GetConsoleMode(handle, &dwMode))
    {
        return FALSE;
    }

    GATE_FLAG_SET(dwMode, ENABLE_PROCESSED_OUTPUT, true);
    GATE_FLAG_SET(dwMode, ENABLE_WRAP_AT_EOL_OUTPUT, true);
    ret = SetConsoleMode(handle, dwMode);
    if (GATE_SUCCEEDED(ret))
    {
        // VT100 support is optional (not available before Windows 10)
        GATE_FLAG_SET(dwMode, ENABLE_VIRTUAL_TERMINAL_PROCESSING, GATE_FLAG_ENABLED(flags, GATE_TERMINAL_FLAG_VT100));
    }
    return ret;
}

#endif

gate_terminal_t* gate_terminal_console_get_current()
{
    gate_terminal_t* ret = NULL;
    gate_terminal_console_impl_t* impl = NULL;
    HANDLE hProc = GetCurrentProcess();
    HANDLE hConOut, hConIn, hConErr;
    HANDLE hOutput = INVALID_HANDLE_VALUE;
    HANDLE hInput = INVALID_HANDLE_VALUE;
    HANDLE hError = INVALID_HANDLE_VALUE;

    do
    {
        /* OUTPUT handle */
#if defined(GATE_SYS_WINCE)
#	if defined(GATE_COMPILER_MSVC)
        hConOut = (HANDLE)fileno(stdout);
        hConIn = (HANDLE)fileno(stdin);
        hConErr = (HANDLE)fileno(stderr);
#	else
        hConOut = (HANDLE)STDOUT_FILENO;
        hConIn = (HANDLE)STDIN_FILENO;
        hConErr = (HANDLE)STDERR_FILENO;
#	endif
#else
        hConOut = GetStdHandle(STD_OUTPUT_HANDLE);
        hConIn = GetStdHandle(STD_INPUT_HANDLE);
        hConErr = GetStdHandle(STD_ERROR_HANDLE);
#endif
        if ((hConOut == INVALID_HANDLE_VALUE) || (hConIn == INVALID_HANDLE_VALUE))
        {
            break;
        }

        if (!DuplicateHandle(hProc, hConOut, hProc, &hOutput, 0, FALSE, DUPLICATE_SAME_ACCESS))
        {
            break;
        }
        if (!DuplicateHandle(hProc, hConIn, hProc, &hInput, 0, FALSE, DUPLICATE_SAME_ACCESS))
        {
            break;
        }
        if (hConErr != INVALID_HANDLE_VALUE)
        {
            if (!DuplicateHandle(hProc, hConErr, hProc, &hError, 0, FALSE, DUPLICATE_SAME_ACCESS))
            {
                break;
            }
        }
        else
        {
            hError = INVALID_HANDLE_VALUE;
        }

        impl = (gate_terminal_console_impl_t*)gate_mem_alloc(sizeof(gate_terminal_console_impl_t));
        if (impl == NULL)
        {
            break;
        }
        gate_mem_clear(impl, sizeof(gate_terminal_console_impl_t));

        gate_init_terminal_console_vtbl();
        impl->vtbl = &gate_terminal_console_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        impl->con_input = hInput;
        impl->con_output = hOutput;
        impl->con_error = hError;
        hInput = NULL;
        hOutput = NULL;
        hError = NULL;

        ret = (gate_terminal_t*)impl;
        impl = NULL;

    } while (0);

    close_file_handle(hInput);
    close_file_handle(hOutput);
    close_file_handle(hError);

    if (impl != NULL)
    {
        gate_mem_dealloc(impl);
    }
    return ret;
}


#ifdef GATE_SYS_WINCE

gate_terminal_t* gate_terminal_console_open(gate_enumint_t flags)
{
    return gate_terminal_console_get_current();
}

#else

gate_terminal_t* gate_terminal_console_open(gate_enumint_t flags)
{
    gate_terminal_t* ret = NULL;
    gate_terminal_console_impl_t* impl = NULL;
    HANDLE hProc = GetCurrentProcess();
    HANDLE hCon = INVALID_HANDLE_VALUE;
    HANDLE hInput = INVALID_HANDLE_VALUE;
    HANDLE hOutput = INVALID_HANDLE_VALUE;
    HANDLE hError = INVALID_HANDLE_VALUE;

    do
    {
        AllocConsole();

        /* open console input buffer */
        hInput = gate_win32_createfile(_T("CONIN$"),
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            OPEN_EXISTING, 0, 0, NULL);
        if (INVALID_HANDLE_VALUE == hInput)
        {
            /* try stdin as alternative */
            if (!DuplicateHandle(hProc, GetStdHandle(STD_INPUT_HANDLE), hProc, &hInput, 0, FALSE, DUPLICATE_SAME_ACCESS))
            {
                break;
            }
        }

        /* open console output buffer */
        hCon = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
        if (INVALID_HANDLE_VALUE == hCon)
        {
            break;
        }

        if (!DuplicateHandle(hProc, hCon, hProc, &hOutput, 0, FALSE, DUPLICATE_SAME_ACCESS))
        {
            break;
        }
        if (!DuplicateHandle(hProc, hCon, hProc, &hError, 0, FALSE, DUPLICATE_SAME_ACCESS))
        {
            break;
        }

        impl = (gate_terminal_console_impl_t*)gate_mem_alloc(sizeof(gate_terminal_console_impl_t));
        if (impl == NULL)
        {
            break;
        }

        if (!SetConsoleActiveScreenBuffer(hOutput))
        {
            break;
        }

        if (!gate_terminal_console_set_output_flags(hOutput, flags))
        {
            break;
        }
        if (!gate_terminal_console_set_input_flags(hInput, flags))
        {
            break;
        }

        gate_mem_clear(impl, sizeof(gate_terminal_console_impl_t));

        gate_init_terminal_console_vtbl();
        impl->vtbl = &gate_terminal_console_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        impl->con_input = hInput;
        impl->con_output = hOutput;
        impl->con_error = hError;
        impl->flags = flags;
        hInput = NULL;
        hOutput = NULL;
        hError = NULL;

        ret = (gate_terminal_t*)impl;
        impl = NULL;

    } while (0);

    close_file_handle(hCon);
    close_file_handle(hInput);
    close_file_handle(hOutput);
    close_file_handle(hError);

    if (impl != NULL)
    {
        gate_mem_dealloc(impl);
    }
    return ret;
}
#endif

void gate_terminal_console_release(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    if (0 == gate_atomic_int_dec(&impl->ref_counter))
    {
        close_file_handle(impl->con_input);
        close_file_handle(impl->con_output);
        close_file_handle(impl->con_error);
        gate_mem_dealloc(impl);
    }
}

int gate_terminal_console_retain(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    return gate_atomic_int_inc(&impl->ref_counter);
}

char const* gate_terminal_console_get_interface_name(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_INTERFACE_NAME_TERMINAL;
}

gate_result_t gate_terminal_console_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    DWORD chars_read;
    do
    {
#ifdef GATE_SYS_WINCE
        if (!gate_win32_readfile(impl->con_input, buffer, (DWORD)bufferlength, &chars_read, NULL))
#else
        if (!ReadConsole(impl->con_input, buffer, (DWORD)bufferlength, &chars_read, NULL))
#endif
        {
            DWORD lasterr = GetLastError();
            if (lasterr != ERROR_INVALID_FUNCTION)
            {
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
                break;
            }
            if (!gate_win32_readfile(impl->con_input, buffer, (DWORD)bufferlength, &chars_read, NULL))
            {
                lasterr = GetLastError();
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
                break;
            }
        }
        if ((gate_size_t)chars_read < bufferlength)
        {
            buffer[chars_read] = 0;
        }
        if (returned)
        {
            *returned = (gate_size_t)chars_read;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}

gate_result_t gate_terminal_console_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(returned);
    return GATE_RESULT_NOTSUPPORTED;
}

static gate_result_t gate_terminal_console_write_to_handle(HANDLE handle, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_result_t ret = GATE_RESULT_OK;
    DWORD chars_written = 0;
    TCHAR text_buffer[7168];
    TCHAR* ptr_text = &text_buffer[0];
    gate_size_t text_len = sizeof(text_buffer) / sizeof(text_buffer[0]);
    gate_size_t text_used;
    do
    {
        if (bufferlength > text_len)
        {
            text_len = bufferlength * sizeof(TCHAR);
            ptr_text = (TCHAR*)gate_mem_alloc(text_len);
            if (ptr_text == NULL)
            {
                ret = GATE_RESULT_FAILED;
                break;
            }
        }

        text_used = gate_win32_utf8_2_winstr(buffer, bufferlength, ptr_text, text_len);
#ifdef GATE_SYS_WINCE
        if (!gate_win32_writefile(handle, buffer, (DWORD)bufferlength, &chars_written, NULL))
#else
        if (!WriteConsole(handle, ptr_text, (DWORD)text_used, &chars_written, NULL))
#endif
        {
            DWORD lasterr = GetLastError();
            if (lasterr != ERROR_INVALID_FUNCTION)
            {
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
                break;
            }

            if (!gate_win32_writefile(handle, buffer, (DWORD)bufferlength, &chars_written, NULL))
            {
                lasterr = GetLastError();
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
                break;
            }
        }

        if (NULL != written)
        {
            if (chars_written == text_used)
            {
                *written = bufferlength;
            }
            else
            {
                *written = (gate_size_t)chars_written;
            }
        }
        ret = GATE_RESULT_OK;
    } while (0);

    if ((ptr_text != NULL) && (ptr_text != &text_buffer[0]))
    {
        gate_mem_dealloc(ptr_text);
    }

    return ret;

}

gate_result_t gate_terminal_console_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    return gate_terminal_console_write_to_handle(impl->con_output, buffer, bufferlength, written);
}

gate_result_t gate_terminal_console_flush(void* thisptr)
{
    gate_result_t ret = GATE_RESULT_OK;
    GATE_UNUSED_ARG(thisptr);
    return ret;
}

gate_result_t gate_terminal_console_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* resource)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    /* TODO */
    do
    {
        if (!resource)
        {
            ret = GATE_RESULT_NULLPOINTER;
            break;
        }

        switch (resource_type)
        {
        case GATE_STREAM_RESOURCE_DEFAULT:
        case GATE_STREAM_RESOURCE_INPUT:
        {
            *resource = (gate_uintptr_t)impl->con_input;
            ret = GATE_RESULT_OK;
        }
        case GATE_STREAM_RESOURCE_OUTPUT:
        {
            *resource = (gate_uintptr_t)impl->con_output;
            ret = GATE_RESULT_OK;
        }
        case GATE_STREAM_RESOURCE_ERROR:
        {
            *resource = (gate_uintptr_t)impl->con_error;
            ret = GATE_RESULT_OK;
        }
        default:
        {
            ret = GATE_RESULT_NOTSUPPORTED;
            break;
        }
        }

    } while (0);

    return ret;
}

static gate_char32_t map_scan_code_to_ctrl_ascii_code(WORD vkey_code)
{
    if ((vkey_code >= 0x41) && (vkey_code <= 0x5A))
    {
        return GATE_TERMINAL_CHAR_CTRL_A + (vkey_code - 0x41);
    }
    return 0;
}

static gate_char32_t gate_scan_code_to_alt_ascii_code(WORD vkey_code)
{
    if ((vkey_code >= 0x41) && (vkey_code <= 0x5A))
    {
        switch ((vkey_code - 0x41))
        {
        case 0: return GATE_TERMINAL_CHAR_ALT_A;
        case 1: return GATE_TERMINAL_CHAR_ALT_B;
        case 2: return GATE_TERMINAL_CHAR_ALT_C;
        case 3: return GATE_TERMINAL_CHAR_ALT_D;
        case 4: return GATE_TERMINAL_CHAR_ALT_E;
        case 5: return GATE_TERMINAL_CHAR_ALT_F;
        case 6: return GATE_TERMINAL_CHAR_ALT_G;
        case 7: return GATE_TERMINAL_CHAR_ALT_H;
        case 8: return GATE_TERMINAL_CHAR_ALT_I;
        case 9: return GATE_TERMINAL_CHAR_ALT_J;
        case 10: return GATE_TERMINAL_CHAR_ALT_K;
        case 11: return GATE_TERMINAL_CHAR_ALT_L;
        case 12: return GATE_TERMINAL_CHAR_ALT_M;
        case 13: return GATE_TERMINAL_CHAR_ALT_N;
        case 14: return GATE_TERMINAL_CHAR_ALT_O;
        case 15: return GATE_TERMINAL_CHAR_ALT_P;
        case 16: return GATE_TERMINAL_CHAR_ALT_Q;
        case 17: return GATE_TERMINAL_CHAR_ALT_R;
        case 18: return GATE_TERMINAL_CHAR_ALT_S;
        case 19: return GATE_TERMINAL_CHAR_ALT_T;
        case 20: return GATE_TERMINAL_CHAR_ALT_U;
        case 21: return GATE_TERMINAL_CHAR_ALT_V;
        case 22: return GATE_TERMINAL_CHAR_ALT_W;
        case 23: return GATE_TERMINAL_CHAR_ALT_X;
        case 24: return GATE_TERMINAL_CHAR_ALT_Y;
        case 25: return GATE_TERMINAL_CHAR_ALT_Z;
        }
    }
    else
    {
        switch (vkey_code)
        {
        case VK_F1: return GATE_TERMINAL_CHAR_ALT_F1;
        case VK_F2: return  GATE_TERMINAL_CHAR_ALT_F2;
        case VK_F3: return  GATE_TERMINAL_CHAR_ALT_F3;
        case VK_F4: return  GATE_TERMINAL_CHAR_ALT_F4;
        case VK_F5: return  GATE_TERMINAL_CHAR_ALT_F5;
        case VK_F6: return  GATE_TERMINAL_CHAR_ALT_F6;
        case VK_F7: return  GATE_TERMINAL_CHAR_ALT_F7;
        case VK_F8: return  GATE_TERMINAL_CHAR_ALT_F8;
        case VK_F9: return  GATE_TERMINAL_CHAR_ALT_F9;
        case VK_F10: return  GATE_TERMINAL_CHAR_ALT_F10;
        case VK_F11: return  GATE_TERMINAL_CHAR_ALT_F11;
        case VK_F12: return  GATE_TERMINAL_CHAR_ALT_F12;
        }
    }
    return 0;
}

static gate_char32_t gate_special_key_to_ascii_code(WORD vkey)
{
    switch (vkey)
    {
    case VK_PRIOR:	return GATE_TERMINAL_CHAR_PGUP;
    case VK_NEXT:	return GATE_TERMINAL_CHAR_PGDOWN;
    case VK_HOME:	return GATE_TERMINAL_CHAR_HOME;
    case VK_END:	return GATE_TERMINAL_CHAR_END;
    case VK_UP:		return GATE_TERMINAL_CHAR_UPARROW;
    case VK_DOWN:	return GATE_TERMINAL_CHAR_DOWNARROW;
    case VK_LEFT:	return GATE_TERMINAL_CHAR_LEFTARROW;
    case VK_RIGHT:	return GATE_TERMINAL_CHAR_RIGHTARROW;

    case VK_F1:		return GATE_TERMINAL_CHAR_F1;
    case VK_F2:		return GATE_TERMINAL_CHAR_F2;
    case VK_F3:		return GATE_TERMINAL_CHAR_F3;
    case VK_F4:		return GATE_TERMINAL_CHAR_F4;
    case VK_F5:		return GATE_TERMINAL_CHAR_F5;
    case VK_F6:		return GATE_TERMINAL_CHAR_F6;
    case VK_F7:		return GATE_TERMINAL_CHAR_F7;
    case VK_F8:		return GATE_TERMINAL_CHAR_F8;
    case VK_F9:		return GATE_TERMINAL_CHAR_F9;
    case VK_F10:	return GATE_TERMINAL_CHAR_F10;
    case VK_F11:	return GATE_TERMINAL_CHAR_F11;
    case VK_F12:	return GATE_TERMINAL_CHAR_F12;

    case VK_TAB:
    case VK_CAPITAL:
    case VK_BACK:
    case VK_RETURN:
    case VK_ESCAPE:
    case VK_INSERT:
    case VK_DELETE:
    case VK_PRINT:
    case VK_PAUSE:
    case VK_SCROLL:
    case VK_NUMLOCK:
    default:
        return 0;
    }
}

gate_result_t gate_terminal_console_read_char_impl(void* thisptr, gate_char32_t* ptr_char, gate_uint32_t timeout_ms)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
#ifdef GATE_SYS_WINCE
    ret = GATE_RESULT_NOTSUPPORTED;
#else
    gate_timecounter_t tc_start;
    gate_timecounter_t tc_now;
    gate_int64_t time_diff;
    DWORD wait = timeout_ms;
    INPUT_RECORD input_record = GATE_INIT_EMPTY;
    DWORD event_count;
    DWORD wait_result;
    gate_char32_t chr;

    /* TODO */

    do
    {
        ret = gate_timecounter_now(&tc_start);
        GATE_BREAK_IF_FAILED(ret);

        if (impl->char_buffer_used != 0)
        {
            if (ptr_char)
            {
                *ptr_char = impl->char_buffer[0];
            }
            if (--impl->char_buffer_used != 0)
            {
                gate_mem_copy(&impl->char_buffer[0], &impl->char_buffer[1], impl->char_buffer_used * sizeof(impl->char_buffer[0]));
            }
            return GATE_RESULT_OK;
        }

        ret = GATE_RESULT_FAILED;
        while (WAIT_OBJECT_0 == (wait_result = WaitForSingleObject(impl->con_input, wait)))
        {
            event_count = 0;
            if (!ReadConsoleInput(impl->con_input, &input_record, 1, &event_count))
            {
                GATE_DEBUG_TRACE("ReadConsoleInput() failed");
                GATE_DEBUG_TRACE_VALUE(gate_win32_getlasterror());
            }
            else
            {
                if (input_record.EventType == KEY_EVENT)
                {
                    if (input_record.Event.KeyEvent.bKeyDown)
                    {
                        if ((input_record.Event.KeyEvent.dwControlKeyState & LEFT_CTRL_PRESSED)
                            || ((input_record.Event.KeyEvent.dwControlKeyState & RIGHT_CTRL_PRESSED)))
                        {
                            chr = map_scan_code_to_ctrl_ascii_code(input_record.Event.KeyEvent.wVirtualKeyCode);
                            if (chr != 0)
                            {
                                if (ptr_char)
                                {
                                    *ptr_char = chr;
                                }
                                else
                                {
                                    impl->char_buffer[0] = chr;
                                    impl->char_buffer_used = 1;
                                }
                                ret = GATE_RESULT_OK;
                                break;
                            }
                        }

                        if ((input_record.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED)
                            || ((input_record.Event.KeyEvent.dwControlKeyState & RIGHT_ALT_PRESSED)))
                        {
                            chr = gate_scan_code_to_alt_ascii_code(input_record.Event.KeyEvent.wVirtualScanCode);
                            if (chr != 0)
                            {
                                if (ptr_char)
                                {
                                    *ptr_char = 0;
                                    impl->char_buffer[0] = chr;
                                    impl->char_buffer_used = 1;
                                }
                                else
                                {
                                    impl->char_buffer[0] = 0;
                                    impl->char_buffer[1] = chr;
                                    impl->char_buffer_used = 2;
                                }
                                ret = GATE_RESULT_OK;
                                break;
                            }
                        }

                        chr = gate_special_key_to_ascii_code(input_record.Event.KeyEvent.wVirtualScanCode);
                        if (chr != 0)
                        {
                            if (ptr_char)
                            {
                                *ptr_char = 0;
                                impl->char_buffer[0] = chr;
                                impl->char_buffer_used = 1;
                            }
                            else
                            {
                                impl->char_buffer[0] = 0;
                                impl->char_buffer[1] = chr;
                                impl->char_buffer_used = 2;
                            }
                            ret = GATE_RESULT_OK;
                            break;
                        }

                        if (input_record.Event.KeyEvent.uChar.UnicodeChar != 0)
                        {
                            /* we have an unicode character */
                            if (ptr_char)
                            {
                                *ptr_char = input_record.Event.KeyEvent.uChar.UnicodeChar;
                            }
                            else
                            {
                                impl->char_buffer[0] = input_record.Event.KeyEvent.uChar.UnicodeChar;
                                impl->char_buffer_used = 1;
                            }
                            ret = GATE_RESULT_OK;
                            break;
                        }

                        /* we could not deduce a code for an entered key -> ignore input */
                    }
                }
            }

            ret = gate_timecounter_now(&tc_now);
            GATE_BREAK_IF_FAILED(ret);

            time_diff = gate_timecounter_diff(tc_now, tc_start) / 1000;
            if (time_diff >= timeout_ms)
            {
                ret = GATE_RESULT_TIMEOUT;
                break;
            }
            wait = (DWORD)(timeout_ms - time_diff);
        }
        if (wait_result == WAIT_TIMEOUT)
        {
            ret = GATE_RESULT_TIMEOUT;
        }
        else if (wait_result != WAIT_OBJECT_0)
        {
            ret = GATE_RESULT_FAILED;
        }
    } while (0);
#endif
    return ret;
}

static gate_bool_t is_control_key(WORD keyCode)
{
    switch (keyCode)
    {
    case VK_SHIFT:
    case VK_CONTROL:
    case VK_MENU:
    case VK_LSHIFT:
    case VK_RSHIFT:
    case VK_LCONTROL:
    case VK_RCONTROL:
    case VK_LMENU:
    case VK_RMENU:
        return true;
    default:
        return false;
    }
}

gate_result_t gate_terminal_console_await_char(void* thisptr, gate_uint32_t timeout_ms)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* ptr = (gate_terminal_console_impl_t*)thisptr;
#ifdef GATE_SYS_WINCE
    ret = GATE_RESULT_NOTSUPPORTED;
#else
    gate_timecounter_t tc_start;
    gate_timecounter_t tc_now;
    gate_int64_t time_diff;
    DWORD next_timeout = (timeout_ms == GATE_CONSOLE_TIMEOUT_NEVER) ? INFINITE : (DWORD)timeout_ms;
    INPUT_RECORD input_record = GATE_INIT_EMPTY;
    DWORD event_count;
    DWORD wait_result;

    HANDLE input_handle = ptr->con_input;

    do
    {
        ret = gate_timecounter_now(&tc_start);
        GATE_BREAK_IF_FAILED(ret);

        ret = GATE_RESULT_FAILED;
        while (WAIT_OBJECT_0 == (wait_result = WaitForSingleObject(input_handle, next_timeout)))
        {
            event_count = 0;
            if (PeekConsoleInput(input_handle, &input_record, 1, &event_count))
            {
                if (input_record.EventType != KEY_EVENT)
                {
                    /* not interested in out events -> remove event from buffer */
                    ReadConsoleInput(input_handle, &input_record, 1, &event_count);
                }
                else if (!input_record.Event.KeyEvent.bKeyDown)
                {
                    /* not interested in key_up -> remove event */
                    ReadConsoleInput(input_handle, &input_record, 1, &event_count);
                }
                else if (is_control_key(input_record.Event.KeyEvent.wVirtualKeyCode))
                {
                    /* ignore control keys -> remove event */
                    ReadConsoleInput(input_handle, &input_record, 1, &event_count);
                }
                else
                {
                    /* next event is a readable key */
                    ret = GATE_RESULT_OK;
                    break;
                }
            }

            ret = gate_timecounter_now(&tc_now);
            GATE_BREAK_IF_FAILED(ret);

            time_diff = gate_timecounter_diff(tc_now, tc_start) / 1000;
            if (time_diff >= timeout_ms)
            {
                ret = GATE_RESULT_TIMEOUT;
                break;
            }
            next_timeout = (DWORD)(timeout_ms - time_diff);
        }
        if (wait_result == WAIT_TIMEOUT)
        {
            ret = GATE_RESULT_TIMEOUT;
        }
        else if (wait_result != WAIT_OBJECT_0)
        {
            ret = GATE_RESULT_FAILED;
        }
    } while (0);
#endif
    return ret;
}

gate_result_t gate_terminal_console_read_char(void* thisptr, gate_char32_t* ptr_char)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* ptr = (gate_terminal_console_impl_t*)thisptr;
#ifdef GATE_SYS_WINCE
    ret = GATE_RESULT_NOTSUPPORTED;
#else
    INPUT_RECORD input_record = GATE_INIT_EMPTY;
    DWORD event_count = 0;
    gate_char32_t chr;
    HANDLE input_handle = ptr->con_input;

    do
    {
        ret = gate_terminal_console_await_char(thisptr, GATE_CONSOLE_TIMEOUT_NEVER);
        GATE_BREAK_IF_FAILED(ret);

        event_count = 0;
        if (!ReadConsoleInput(input_handle, &input_record, 1, &event_count))
        {
            ret = GATE_RESULT_FAILED;
            break;
        }
        if (input_record.EventType != KEY_EVENT)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }
        if (!input_record.Event.KeyEvent.bKeyDown)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }

#if defined(GATE_WIN32_UNICODE)
        chr = input_record.Event.KeyEvent.uChar.UnicodeChar;
#else
        chr = input_record.Event.KeyEvent.uChar.AsciiChar;
#endif
        if (chr == 0)
        {
            gate_keyboard_native_key_to_unicode(input_record.Event.KeyEvent.wVirtualKeyCode, &chr);
        }
        *ptr_char = chr;

    } while (0);
#endif
    return ret;
}


gate_result_t gate_terminal_console_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_terminal_console_impl_t* const impl = (gate_terminal_console_impl_t*)thisptr;
    return gate_terminal_console_write_to_handle(impl->con_error, buffer, bufferlength, written);
}

gate_result_t gate_terminal_console_flush_err(void* thisptr)
{
    gate_result_t ret = GATE_RESULT_OK;
    GATE_UNUSED_ARG(thisptr);
    return ret;
}

#ifndef GATE_SYS_WINCE
static gate_bool_t is_real_console(gate_terminal_console_impl_t* impl)
{
    DWORD con_mode = 0;
    BOOL is_console = GetConsoleMode(impl->con_output, &con_mode);
    return is_console ? true : false;
}
#endif

gate_enumint_t gate_terminal_console_get_type(void* thisptr)
{
#ifdef GATE_SYS_WINCE
    return GATE_TERMINAL_TYPE_CHARSTREAM;
#else
    gate_terminal_console_impl_t* const impl = (gate_terminal_console_impl_t*)thisptr;
    return is_real_console(impl) ? GATE_TERMINAL_TYPE_UI : GATE_TERMINAL_TYPE_CHARSTREAM;
#endif
}

gate_result_t gate_terminal_console_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* const impl = (gate_terminal_console_impl_t*)thisptr;
    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_SCREEN_BUFFER_INFO info;
            if (!GetConsoleScreenBufferInfo(impl->con_output, &info))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    if (ptr_width != NULL) *ptr_width = 80;
                    if (ptr_height != NULL) *ptr_height = 25;
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                if (ptr_width != NULL) *ptr_width = (gate_uint16_t)info.dwSize.X;
                if (ptr_height != NULL) *ptr_height = (gate_uint16_t)info.dwSize.Y;
                ret = GATE_RESULT_OK;
            }
            break;
        }
#endif
        ret = gate_terminal_vt100_get_size(thisptr, ptr_width, ptr_height);
    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* const impl = (gate_terminal_console_impl_t*)thisptr;
    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_SCREEN_BUFFER_INFO info;
            if (!GetConsoleScreenBufferInfo(impl->con_output, &info))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    // return fake values
                    if (ptr_x != NULL) *ptr_x = 0;
                    if (ptr_y != NULL) *ptr_y = 0;
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                if (ptr_x != NULL) *ptr_x = (gate_uint16_t)info.dwCursorPosition.X;
                if (ptr_y != NULL) *ptr_y = (gate_uint16_t)info.dwCursorPosition.Y;
                ret = GATE_RESULT_OK;
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_get_cursor_pos(thisptr, ptr_x, ptr_y);
    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            COORD coord;
            coord.X = (SHORT)x;
            coord.Y = (SHORT)y;
            if (!SetConsoleCursorPosition(impl->con_output, coord))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    /* no action, but simulate success */
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                ret = GATE_RESULT_OK;
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_set_cursor_pos(thisptr, x, y);

    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_set_cursor_mode(void* thisptr, gate_uint16_t mode)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;

    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_CURSOR_INFO info = GATE_INIT_EMPTY;

            switch (mode)
            {
            case GATE_TERMINAL_CURSOR_MODE_OFF:
            {
                info.bVisible = false;
                info.dwSize = 1;
                break;
            }
            case GATE_TERMINAL_CURSOR_MODE_SMALL:
            {
                info.bVisible = true;
                info.dwSize = 15;
                break;
            }
            case GATE_TERMINAL_CURSOR_MODE_MEDIUM:
            {
                info.bVisible = true;
                info.dwSize = 50;
                break;
            }
            case GATE_TERMINAL_CURSOR_MODE_LARGE:
            default:
            {
                info.bVisible = true;
                info.dwSize = 100;
                break;
            }
            }
            if (SetConsoleCursorInfo(impl->con_output, &info))
            {
                ret = GATE_RESULT_OK;
                break;
            }
            else
            {
                if (!is_real_console(impl))
                {
                    /* simluate success */
                    ret = GATE_RESULT_OK;
                    break;
                }
            }
        }
#endif
        ret = gate_terminal_vt100_enable_cursor(impl, (mode == GATE_TERMINAL_CURSOR_MODE_OFF) ? false : true);

    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_clear(void* thisptr)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            do
            {
                COORD coordScreen = { 0, 0 };
                DWORD cCharsWritten;
                CONSOLE_SCREEN_BUFFER_INFO csbi;
                DWORD dwConSize;

                if (!GetConsoleScreenBufferInfo(impl->con_output, &csbi))
                {
                    DWORD lasterr = GetLastError();
                    if (!is_real_console(impl))
                    {
                        /* no change, simulate success */
                        ret = GATE_RESULT_OK;
                        break;
                    }
                    gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
                    break;
                }
                dwConSize = csbi.dwSize.X * csbi.dwSize.Y;

                if (!FillConsoleOutputCharacter(impl->con_output, _T(' '), dwConSize, coordScreen, &cCharsWritten))
                {
                    gate_win32_print_lasterror(&ret, NULL, 0);
                    break;
                }
                if (!GetConsoleScreenBufferInfo(impl->con_output, &csbi))
                {
                    gate_win32_print_lasterror(&ret, NULL, 0);
                    break;
                }
                if (!FillConsoleOutputAttribute(impl->con_output, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten))
                {
                    gate_win32_print_lasterror(&ret, NULL, 0);
                    break;
                }
                if (!SetConsoleCursorPosition(impl->con_output, coordScreen))
                {
                    gate_win32_print_lasterror(&ret, NULL, 0);
                    break;
                }
                ret = GATE_RESULT_OK;
            } while (0);

            if (GATE_SUCCEEDED(ret))
            {
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_clear(thisptr);
    } while (0);

    return ret;
}

gate_result_t gate_terminal_console_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;

    do
    {
#ifndef GATE_SYS_WINCE
        //if(!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_SCREEN_BUFFER_INFO info;
            if (!GetConsoleScreenBufferInfo(impl->con_output, &info))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    if (ptr_color_code != NULL) *ptr_color_code = GATE_TERMINAL_COLOR_WHITE;
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                if (ptr_color_code != NULL)
                {
                    *ptr_color_code = info.wAttributes & 0x0f;
                }
                ret = GATE_RESULT_OK;
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_get_text_color(thisptr, ptr_color_code);
    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_set_text_color(void* thisptr, gate_uint8_t color_code)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;

    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_SCREEN_BUFFER_INFO info = GATE_INIT_EMPTY;
            GetConsoleScreenBufferInfo(impl->con_output, &info);
            info.wAttributes &= 0xfff0;
            info.wAttributes |= (gate_uint16_t)color_code;
            if (!SetConsoleTextAttribute(impl->con_output, info.wAttributes))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                ret = GATE_RESULT_OK;
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_set_text_color(thisptr, color_code);
    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    do
    {
#ifndef GATE_SYS_WINCE
        //if(!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_SCREEN_BUFFER_INFO info;
            if (!GetConsoleScreenBufferInfo(impl->con_output, &info))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    if (ptr_color_code) *ptr_color_code = GATE_TERMINAL_COLOR_BLACK;
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                if (NULL != ptr_color_code)
                {
                    *ptr_color_code = (info.wAttributes >> 4) & 0x0f;
                }
                ret = GATE_RESULT_OK;
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_get_back_color(thisptr, ptr_color_code);
    } while (0);
    return ret;
}

gate_result_t gate_terminal_console_set_back_color(void* thisptr, gate_uint8_t color_code)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    do
    {
#ifndef GATE_SYS_WINCE
        if (!GATE_FLAG_ENABLED(impl->flags, GATE_TERMINAL_FLAG_VT100))
        {
            CONSOLE_SCREEN_BUFFER_INFO info = GATE_INIT_EMPTY;
            GetConsoleScreenBufferInfo(impl->con_output, &info);
            info.wAttributes &= 0xff0f;
            info.wAttributes |= (((gate_uint16_t)(color_code) << 4) & 0x00f0);
            if (!SetConsoleTextAttribute(impl->con_output, info.wAttributes))
            {
                DWORD lasterr = GetLastError();
                if (!is_real_console(impl))
                {
                    /* no action, simulate success */
                    ret = GATE_RESULT_OK;
                    break;
                }
                gate_win32_print_lasterror_code(lasterr, &ret, NULL, 0);
            }
            else
            {
                ret = GATE_RESULT_OK;
                break;
            }
        }
#endif
        ret = gate_terminal_vt100_set_back_color(thisptr, color_code);
    } while (0);
    return ret;
}

#endif /* GATE_SYSTEM_TERMINALS_WINAPI */


#if defined(GATE_SYSTEM_TERMINALS_POSIX)

#	include <sys/ioctl.h>
#	include <sys/types.h>
#	include <sys/select.h>
#	include <sys/wait.h>
#	include <unistd.h>
#	include <stdio.h>
#	include <termios.h>

typedef struct gate_terminal_console_impl_class
{
    GATE_INTERFACE_VTBL(gate_terminal) const* vtbl;

    gate_atomic_int_t	ref_counter;

    int con_input;
    int con_output;
    int con_error;
    int text_color;
    int back_color;

    gate_bool_t restore_termios;
    struct termios termios_attrs_backup;

} gate_terminal_console_impl_t;

static gate_terminal_console_impl_t* gate_terminal_console_create(int fd_in, int fd_out, int fd_err)
{
    gate_terminal_console_impl_t* impl = gate_mem_alloc(sizeof(gate_terminal_console_impl_t));
    if (impl != NULL)
    {
        gate_mem_clear(impl, sizeof(gate_terminal_console_impl_t));
        gate_init_terminal_console_vtbl();
        impl->vtbl = &gate_terminal_console_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        impl->con_input = fd_in;	//STDIN_FILENO;
        impl->con_output = fd_out;	//STDOUT_FILENO;
        impl->con_error = fd_err;	//STDERR_FILENO;
        impl->text_color = GATE_TERMINAL_COLOR_WHITE;
        impl->back_color = GATE_TERMINAL_COLOR_BLACK;
        gate_terminal_set_text_color(impl, GATE_TERMINAL_COLOR_WHITE);
        gate_terminal_set_back_color(impl, GATE_TERMINAL_COLOR_BLACK);
    }
    return impl;
}

gate_terminal_t* gate_terminal_console_get_current()
{
    return gate_terminal_console_open(0);
}

gate_terminal_t* gate_terminal_console_open(gate_enumint_t flags)
{
    gate_terminal_console_impl_t* term = NULL;
    struct termios termios_attrs;

    int fd_in = dup(STDIN_FILENO);
    int fd_out = dup(STDOUT_FILENO);
    int fd_err = dup(STDERR_FILENO);

    term = gate_terminal_console_create(fd_in, fd_out, fd_err);

    if (!term)
    {
        gate_posix_close(fd_in);
        gate_posix_close(fd_out);
        gate_posix_close(fd_err);
    }
    else
    {
        if (0 == tcgetattr(term->con_input, &term->termios_attrs_backup))
        {
            gate_mem_copy(&termios_attrs, &term->termios_attrs_backup, sizeof(struct termios));
            term->restore_termios = true;
            GATE_FLAG_SET(termios_attrs.c_lflag, ICANON, false);
            GATE_FLAG_SET(termios_attrs.c_lflag, ECHO, GATE_FLAG_ENABLED(flags, GATE_TERMINAL_FLAG_ECHO));
            GATE_FLAG_SET(termios_attrs.c_lflag, ECHONL, GATE_FLAG_ENABLED(flags, GATE_TERMINAL_FLAG_ECHO));
            GATE_FLAG_SET(termios_attrs.c_lflag, ISIG, false);
            GATE_FLAG_SET(termios_attrs.c_lflag, IEXTEN, false);
            tcsetattr(term->con_input, TCSANOW, &termios_attrs);
        }
    }
    return (gate_terminal_t*)term;
}


static void	gate_terminal_console_release(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    if (0 == gate_atomic_int_dec(&impl->ref_counter))
    {
        if (impl->restore_termios)
        {
            tcsetattr(impl->con_input, TCSANOW, &impl->termios_attrs_backup);
        }
        gate_posix_close(impl->con_input);
        gate_posix_close(impl->con_output);
        gate_posix_close(impl->con_error);
        gate_mem_dealloc(impl);
    }
}
static int gate_terminal_console_retain(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    return gate_atomic_int_dec(&impl->ref_counter);
}
static char const* gate_terminal_console_get_interface_name(void* thisptr)
{
    return GATE_INTERFACE_NAME_TERMINAL;
}

static gate_result_t gate_terminal_console_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    ptrdiff_t result = gate_posix_read(impl->con_input, buffer, bufferlength);
    if (result < 0)
    {
        gate_posix_errno(&ret);
    }
    else
    {
        if (NULL != returned)
        {
            *returned = (gate_size_t)result;
        }
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_terminal_console_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    return GATE_RESULT_NOTSUPPORTED;
}
static gate_result_t gate_terminal_console_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    ptrdiff_t result = gate_posix_write(impl->con_output, buffer, bufferlength);
    if (result < 0)
    {
        gate_posix_errno(&ret);
    }
    else
    {
        if (NULL != written)
        {
            *written = (gate_size_t)result;
        }
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_terminal_console_flush(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    if (fsync(impl->con_output) < 0)
    {
        gate_posix_errno(&ret);
    }
    else
    {
        ret = GATE_RESULT_OK;
    }
    return ret;
}

static gate_result_t gate_terminal_console_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* ptr_resource)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_uintptr_t res = 0;
    gate_result_t ret = GATE_RESULT_OK;

    switch (resource_type)
    {
    case GATE_STREAM_RESOURCE_INPUT:	res = impl->con_input; break;
    case GATE_STREAM_RESOURCE_OUTPUT:	res = impl->con_output; break;
    case GATE_STREAM_RESOURCE_ERROR:	res = impl->con_error; break;
    case GATE_STREAM_RESOURCE_DEFAULT:	res = impl->con_input; break;
    default:							ret = GATE_RESULT_INVALIDARG; break;
    }

    if (ptr_resource)
    {
        *ptr_resource = res;
    }
    return ret;
}
static gate_result_t gate_terminal_console_await_char(void* thisptr, gate_uint32_t timeout_ms)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    return gate_posix_await_read(impl->con_input, timeout_ms);
}
static gate_result_t gate_terminal_console_read_char(void* thisptr, gate_char32_t* ptr_char)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    char buffer[8];
    ret = gate_terminal_console_read(impl, buffer, 1, NULL);
    if (ptr_char)
    {
        *ptr_char = (gate_char32_t)(gate_uint8_t)buffer[0];
    }
    return ret;
}
static gate_result_t gate_terminal_console_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    ptrdiff_t result = gate_posix_write(impl->con_error, buffer, bufferlength);
    if (result < 0)
    {
        gate_posix_errno(&ret);
    }
    else
    {
        if (NULL != written)
        {
            *written = (gate_size_t)result;
        }
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_terminal_console_flush_err(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    if (fsync(impl->con_error) < 0)
    {
        gate_posix_errno(&ret);
    }
    else
    {
        ret = GATE_RESULT_OK;
    }
    return ret;
}


gate_enumint_t gate_terminal_console_get_type(void* thisptr)
{
    return GATE_TERMINAL_TYPE_VT100;
}

//"\x1b[0;40;37m\x1b[1;1H\x1b[2J"
static gate_result_t gate_terminal_console_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret;
    struct winsize ws = { 0, 0, 0, 0 };

    if (ioctl(impl->con_output, TIOCGWINSZ, &ws) != -1)
    {
        if (NULL != ptr_width) *ptr_width = (gate_uint16_t)ws.ws_col;
        if (NULL != ptr_height) *ptr_height = (gate_uint16_t)ws.ws_row;
        ret = GATE_RESULT_OK;
    }
    else
    {
        gate_posix_errno(&ret);
    }
    return ret;
}
static gate_result_t gate_terminal_console_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret = GATE_RESULT_NOTSUPPORTED;
    struct termios t;
    /*TODO implementation*/
    (void)impl;
    (void)t;
    (void)ptr_x;
    (void)ptr_y;
    return ret;
}
static gate_result_t gate_terminal_console_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    return gate_terminal_vt100_set_cursor_pos(thisptr, x, y);
}
static gate_result_t gate_terminal_console_set_cursor_mode(void* thisptr, gate_uint16_t mode)
{
    return gate_terminal_vt100_enable_cursor(thisptr, (mode == GATE_TERMINAL_CURSOR_MODE_OFF) ? false : true);
}
static gate_result_t gate_terminal_console_clear(void* thisptr)
{
    return gate_terminal_vt100_clear(thisptr);
}


static gate_result_t gate_terminal_console_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    *ptr_color_code = impl->text_color;
    return GATE_RESULT_OK;
}


static gate_result_t gate_terminal_console_set_text_color(void* thisptr, gate_uint8_t color_code)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret = gate_terminal_vt100_set_text_color(thisptr, color_code);
    if (GATE_SUCCEEDED(ret))
    {
        impl->text_color = color_code;
    }
    return ret;
}

static gate_result_t gate_terminal_console_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    *ptr_color_code = impl->back_color;
    return GATE_RESULT_OK;
}
static gate_result_t gate_terminal_console_set_back_color(void* thisptr, gate_uint8_t color_code)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_result_t ret = gate_terminal_vt100_set_back_color(thisptr, color_code);
    if (GATE_SUCCEEDED(ret))
    {
        impl->back_color = color_code;
    }
    return ret;
}

#endif  /* GATE_SYSTEM_TERMINALS_POSIX */



#if defined(GATE_SYSTEM_TERMINALS_DOS)

#include <graph.h>
#include <conio.h>

static void gate_term_init()
{
    _setvideomode(_TEXTC80);
}
static void gate_term_text_color(int textcol)
{
    _settextcolor(textcol);
}
static void gate_term_back_color(int bkcol)
{
    _setbkcolor(bkcol);
}
static void gate_term_text_cursor_size(int sz_0_to_3)
{
    int value = 0;
    switch (sz_0_to_3)
    {
    case 3:		value = 0x0007; break;	/* full block */
    case 2:		value = 0x0407; break;	/* half size  */
    case 1:		value = 0x0607; break;	/* underline cursor */
    default:	value = 0x2000; break;	/* no cursor /invisible */
    }
    _settextcursor(value);
}
static void gate_term_text_cursor_pos(char y_1_to_25, char x_1_to_80)
{
    _settextposition(y_1_to_25, x_1_to_80);
}
static void gate_term_print_char(char chr)
{
    char buf[2] = { chr, 0 };
    _outtext(buf);
}
static void gate_term_text_cursor_enable(gate_bool_t enabled)
{
    _displaycursor(enabled ? _GCURSORON : _GCURSOROFF);
}
static void gate_term_print_text(char const* text)
{
    char buffer[GATE_MAX_BLOCK_COPYBUFFER_LENGTH];
    gate_str_print_text(buffer, sizeof(buffer), text, gate_str_length(text));
    _outtext(buffer);
}

typedef struct gate_terminal_console_impl_class
{
    GATE_INTERFACE_VTBL(gate_terminal) const* vtbl;

    gate_atomic_int_t	ref_counter;
    gate_uint32_t		flags;
    gate_uint8_t		text_color;
    gate_uint8_t		back_color;
    char 				read_buffer[64];
    gate_size_t			read_buffer_used;

} gate_terminal_console_impl_t;

void gate_terminal_console_release(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    if (0 == gate_atomic_int_dec(&impl->ref_counter))
    {
        gate_mem_dealloc(impl);
    }
}
int gate_terminal_console_retain(void* thisptr)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    return gate_atomic_int_inc(&impl->ref_counter);
}
char const* gate_terminal_console_get_interface_name(void* thisptr)
{
    (void)thisptr;
    return GATE_INTERFACE_NAME_TERMINAL;
}

static gate_size_t gate_term_read_buffer(char* buffer, gate_size_t buffer_length)
{
    gate_size_t count = 0;
    unsigned int ch;
    while ((buffer_length > 0) && gate_dos_has_kbd_event())
    {
        if (!gate_dos_get_next_kbd_event(&ch))
        {
            break;
        }
        *buffer = (char)ch;
        ++buffer;
        ++count;
        --buffer_length;
    }
    return count;
}

gate_result_t gate_terminal_console_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_size_t len = 0;
    unsigned int ch;

    do
    {
        if (!buffer || !bufferlength)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        if (impl->read_buffer_used == 0)
        {
            if (!gate_dos_get_next_kbd_event(&ch))
            {
                break;
            }
            impl->read_buffer[0] = (char)ch;
            impl->read_buffer_used = 1;
            impl->read_buffer_used += gate_term_read_buffer(&impl->read_buffer[1], sizeof(impl->read_buffer) - 1);
        }

        ret = GATE_RESULT_OK;
        len = (bufferlength > impl->read_buffer_used) ? impl->read_buffer_used : bufferlength;
        gate_mem_copy(buffer, impl->read_buffer, len);
        if (returned)
        {
            *returned = len;
        }

        if (len >= impl->read_buffer_used)
        {
            impl->read_buffer_used = 0;
        }
        else if (len > 0)
        {
            gate_mem_copy(&impl->read_buffer[0], &impl->read_buffer[len], impl->read_buffer_used - len);
            impl->read_buffer_used -= len;
        }
    } while (0);

    return ret;
}
gate_result_t gate_terminal_console_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_terminal_console_impl_t* impl = (gate_terminal_console_impl_t*)thisptr;
    gate_size_t len;

    if (!buffer || !bufferlength)
    {
        return GATE_RESULT_INVALIDARG;
    }

    if (impl->read_buffer_used < sizeof(impl->read_buffer))
    {
        len = gate_term_read_buffer(&impl->read_buffer[impl->read_buffer_used], sizeof(impl->read_buffer) - impl->read_buffer_used);
        impl->read_buffer_used += len;
    }

    len = (bufferlength > impl->read_buffer_used) ? impl->read_buffer_used : bufferlength;
    gate_mem_copy(buffer, impl->read_buffer, len);
    if (returned)
    {
        *returned = len;
    }
    return GATE_RESULT_OK;
}
gate_result_t gate_terminal_console_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t processed = 0;

    GATE_UNUSED_ARG(thisptr);

    while (bufferlength > 0)
    {
        gate_term_print_char(*buffer);
        ++buffer;
        ++processed;
        --bufferlength;
    }
    if (written)
    {
        *written = processed;
    }
    return ret;
}
gate_result_t gate_terminal_console_flush(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_RESULT_OK;
}

gate_result_t gate_terminal_console_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* resource)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(resource_type);
    GATE_UNUSED_ARG(resource);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_await_char(void* thisptr, gate_uint32_t timeout_ms)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_dos_await_and_read_kbd(NULL, timeout_ms);
}
gate_result_t gate_terminal_console_read_char(void* thisptr, gate_char32_t* ptr_char)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_dos_await_and_read_kbd(ptr_char, -1);
}

gate_result_t gate_terminal_console_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(written);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_flush_err(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_RESULT_OK;
}

gate_enumint_t gate_terminal_console_get_type(void* thisptr)
{
    return GATE_TERMINAL_TYPE_UI;
}

gate_result_t gate_terminal_console_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    GATE_UNUSED_ARG(thisptr);
    if (ptr_width) *ptr_width = 80;
    if (ptr_height) *ptr_height = 25;
    return GATE_RESULT_OK;
}
gate_result_t gate_terminal_console_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_x);
    GATE_UNUSED_ARG(ptr_y);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    GATE_UNUSED_ARG(thisptr);
    if (x > 79) x = 79;
    if (y > 24) y = 24;
    gate_term_text_cursor_pos(y + 1, x + 1);
    return GATE_RESULT_OK;
}
gate_result_t gate_terminal_console_set_cursor_mode(void* thisptr, gate_uint16_t mode)
{
    GATE_UNUSED_ARG(thisptr);
    gate_term_text_cursor_enable(mode == GATE_TERMINAL_CURSOR_MODE_OFF ? false : true);
    return GATE_RESULT_OK;
}
gate_result_t gate_terminal_console_clear(void* thisptr)
{
    (void)thisptr;
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    (void)thisptr;
    (void)ptr_color_code;
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_text_color(void* thisptr, gate_uint8_t color_code)
{
    (void)thisptr;
    gate_term_text_color(color_code);
    return GATE_RESULT_OK;
}

gate_result_t gate_terminal_console_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    (void)thisptr;
    (void)ptr_color_code;
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_back_color(void* thisptr, gate_uint8_t color_code)
{
    (void)thisptr;
    gate_term_back_color(color_code);
    return GATE_RESULT_OK;
}

gate_terminal_t* gate_terminal_console_get_current()
{
    gate_terminal_console_impl_t* impl = gate_mem_alloc(sizeof(gate_terminal_console_impl_t));
    if (impl != NULL)
    {
        gate_mem_clear(impl, sizeof(gate_terminal_console_impl_t));
        gate_init_terminal_console_vtbl();
        impl->vtbl = &gate_terminal_console_vtbl;
        gate_atomic_int_init(&impl->ref_counter, 1);
        impl->text_color = GATE_TERMINAL_COLOR_WHITE;
        impl->back_color = GATE_TERMINAL_COLOR_BLACK;
        impl->read_buffer_used = 0;
        gate_term_init();
    }
    return (gate_terminal_t*)impl;
}

gate_terminal_t* gate_terminal_console_open(gate_enumint_t flags)
{
    (void)flags;
    return gate_terminal_console_get_current();
}


#endif /* GATE_SYSTEM_TERMINALS_DOS */



#if defined(GATE_SYSTEM_TERMINALS_EFI)

#include "gate/platform/efi/efi_gate.h"

typedef struct
{
    GATE_INTERFACE_VTBL(gate_terminal)* vtbl;

} gate_terminal_console_efi_singleton;

static gate_terminal_t efi_terminal_singleton =
{
    &gate_terminal_console_vtbl
};



void gate_terminal_console_release(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
}
int gate_terminal_console_retain(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return 1;
}
char const* gate_terminal_console_get_interface_name(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_INTERFACE_NAME_TERMINAL;
}

gate_result_t gate_terminal_console_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_result_t result = GATE_RESULT_INVALIDARG;
    gate_uint32_t next_timeout = (gate_uint32_t)-1;
    gate_char16_t chr;
    gate_uint16_t scancode;
    gate_size_t len;
    gate_size_t len_returned = 0;
    GATE_UNUSED_ARG(thisptr);

    while (buffer && (bufferlength > 0))
    {
        result = gate_platform_efi_console_await_char(next_timeout);
        GATE_BREAK_IF_FAILED(result);
        next_timeout = 0;
        result = gate_platform_efi_console_read_char(&chr, &scancode, true);
        GATE_BREAK_IF_FAILED(result);

        len = gate_char_write_utf8((gate_char32_t)chr, buffer, bufferlength);
        len_returned += len;
        buffer += len;
        bufferlength -= len;
    }

    if (returned)
    {
        *returned = len_returned;
    }
    if ((result == GATE_RESULT_TIMEOUT) && (len_returned > 0))
    {
        result = GATE_RESULT_OK;
    }
    return result;
}
gate_result_t gate_terminal_console_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(returned);

    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_result_t result;
    gate_char32_t chr32;
    gate_size_t length;
    gate_size_t bytes_written = 0;

    GATE_UNUSED_ARG(thisptr);

    while (buffer && (bufferlength > 0))
    {
        length = gate_char_read_utf8(buffer, bufferlength, &chr32);
        buffer += length;
        bufferlength -= length;
        result = gate_platform_efi_console_write_char((gate_char16_t)chr32);
        GATE_BREAK_IF_FAILED(result);
        bytes_written += length;
    }
    if (written)
    {
        *written = bytes_written;
    }
    if (GATE_FAILED(result) && (bytes_written > 0))
    {
        result = GATE_RESULT_OK;
    }
    return result;
}
gate_result_t gate_terminal_console_flush(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_RESULT_OK;
}

gate_result_t gate_terminal_console_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* resource)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(resource_type);
    GATE_UNUSED_ARG(resource);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_await_char(void* thisptr, gate_uint32_t timeout_ms)
{
    gate_result_t result;
    GATE_UNUSED_ARG(thisptr);

    result = gate_platform_efi_console_await_char(timeout_ms == GATE_CONSOLE_TIMEOUT_NEVER ? (gate_uint32_t)-1 : timeout_ms);
    return result;
}
gate_result_t gate_terminal_console_read_char(void* thisptr, gate_char32_t* ptr_char)
{
    gate_result_t result;
    gate_char16_t chr16 = 0;
    gate_uint16_t scan_code = 0;
    GATE_UNUSED_ARG(thisptr);
    result = gate_platform_efi_console_read_char(&chr16, &scan_code, false);
    if (ptr_char)
    {
        *ptr_char = (gate_char32_t)chr16;
    }
    return result;
}
gate_result_t gate_terminal_console_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(written);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_flush_err(void* thisptr)
{
    (void)thisptr;
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_enumint_t gate_terminal_console_get_type(void* thisptr)
{
    return GATE_TERMINAL_TYPE_UI;
}

gate_result_t gate_terminal_console_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_platform_efi_console_get_size(ptr_width, ptr_height);
}
gate_result_t gate_terminal_console_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_platform_efi_console_get_cursor_pos(ptr_x, ptr_y);
}
gate_result_t gate_terminal_console_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_platform_efi_console_set_cursor_pos(x, y);
}
gate_result_t gate_terminal_console_set_cursor_mode(void* thisptr, gate_uint16_t mode)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_platform_efi_console_enable_cursor(mode == GATE_TERMINAL_CURSOR_MODE_OFF ? false : true);
}

gate_result_t gate_terminal_console_clear(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return gate_platform_efi_console_clear();
}

gate_result_t gate_terminal_console_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    GATE_UNUSED_ARG(thisptr);
    gate_uint8_t dummy = 0;
    return gate_platform_efi_console_get_color(ptr_color_code, &dummy);
}
gate_result_t gate_terminal_console_set_text_color(void* thisptr, gate_uint8_t color_code)
{
    GATE_UNUSED_ARG(thisptr);
    gate_uint8_t dummy = 0;
    gate_uint8_t backcolor = 0;
    gate_platform_efi_console_get_color(&dummy, &backcolor);
    return gate_platform_efi_console_set_color(color_code, backcolor);
}

gate_result_t gate_terminal_console_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    GATE_UNUSED_ARG(thisptr);
    gate_uint8_t dummy = 0;
    return gate_platform_efi_console_get_color(&dummy, ptr_color_code);
}
gate_result_t gate_terminal_console_set_back_color(void* thisptr, gate_uint8_t color_code)
{
    GATE_UNUSED_ARG(thisptr);
    gate_uint8_t dummy = 0;
    gate_uint8_t textcolor = 0;
    gate_platform_efi_console_get_color(&textcolor, &dummy);
    return gate_platform_efi_console_set_color(textcolor, color_code);
}

gate_terminal_t* gate_terminal_console_get_current()
{
    gate_init_terminal_console_vtbl();
    return &efi_terminal_singleton;
}

gate_terminal_t* gate_terminal_console_open(gate_enumint_t flags)
{
    GATE_UNUSED_ARG(flags);
    gate_init_terminal_console_vtbl();
    return &efi_terminal_singleton;
}

#endif /* GATE_SYSTEM_TERMINALS_EFI*/



#if defined(GATE_SYSTEM_TERMINALS_NOIMPL)

void gate_terminal_console_release(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
}
int gate_terminal_console_retain(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return 1;
}
char const* gate_terminal_console_get_interface_name(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return NULL;
}

gate_result_t gate_terminal_console_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(returned);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(returned);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(written);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_flush(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_get_resource(void* thisptr, gate_uint32_t resource_type, gate_uintptr_t* resource)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(resource_type);
    GATE_UNUSED_ARG(resource);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_await_char(void* thisptr, gate_uint32_t timeout_ms)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(timeout_ms);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_read_char(void* thisptr, gate_char32_t* ptr_char)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_char);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_write_err(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(buffer);
    GATE_UNUSED_ARG(bufferlength);
    GATE_UNUSED_ARG(written);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_flush_err(void* thisptr)
{
    (void)thisptr;
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_enumint_t gate_terminal_console_get_type(void* thisptr)
{
    return GATE_TERMINAL_TYPE_UNKNOWN;
}

gate_result_t gate_terminal_console_get_size(void* thisptr, gate_uint16_t* ptr_width, gate_uint16_t* ptr_height)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_width);
    GATE_UNUSED_ARG(ptr_height);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_get_cursor_pos(void* thisptr, gate_uint16_t* ptr_x, gate_uint16_t* ptr_y)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_x);
    GATE_UNUSED_ARG(ptr_y);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_cursor_pos(void* thisptr, gate_uint16_t x, gate_uint16_t y)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(x);
    GATE_UNUSED_ARG(y);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_cursor_mode(void* thisptr, gate_uint16_t mode)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(mode);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_clear(void* thisptr)
{
    GATE_UNUSED_ARG(thisptr);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_get_text_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_color_code);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_text_color(void* thisptr, gate_uint8_t color_code)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(color_code);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_terminal_console_get_back_color(void* thisptr, gate_uint8_t* ptr_color_code)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(ptr_color_code);
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_terminal_console_set_back_color(void* thisptr, gate_uint8_t color_code)
{
    GATE_UNUSED_ARG(thisptr);
    GATE_UNUSED_ARG(color_code);
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_terminal_t* gate_terminal_console_get_current()
{
    return NULL;
}

gate_terminal_t* gate_terminal_console_open(gate_enumint_t flags)
{
    GATE_UNUSED_ARG(flags);
    return NULL;
}

#endif /* GATE_SYSTEM_TERMINALS_NOIMPL */