diff --git a/.gitignore b/.gitignore index 54bb06f..8120a94 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,5 @@ iso_root */*/*.gch .gdb_history symbols.map -symbols.S \ No newline at end of file +symbols.S +*.log \ No newline at end of file diff --git a/Makefile b/Makefile index 1b3d907..e0bc1e9 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,11 @@ -SOURCES = src/debug/panic.c src/debug/stacktrace.c src/boot/boot.c src/sched/scheduler.c src/sched/process.c src/mem/heap/kheap.c src/mem/paging/vmm.c src/mem/paging/paging.c src/mem/paging/pmm.c src/string/string.c src/io/kbd/ps2.c src/io/serial/serial.c src/io/term/printf.c src/io/term/term.c src/idt/idt.c src/mem/gdt/gdt.c src/mem/misc/utils.c src/time/timer.c src/kmain.c +SOURCES = src/debug/misc.c src/io/term/flanterm_backends/fb.c src/io/term/flanterm.c src/debug/panic.c src/debug/stacktrace.c src/boot/boot.c src/sched/scheduler.c src/sched/process.c src/mem/heap/kheap.c src/mem/paging/vmm.c src/mem/paging/paging.c src/mem/paging/pmm.c src/string/string.c src/io/kbd/ps2.c src/io/serial/serial.c src/io/term/printf.c src/io/term/term.c src/idt/idt.c src/mem/gdt/gdt.c src/mem/misc/utils.c src/time/timer.c src/kmain.c PROBLEMATIC_FLAGS=-Wno-unused-parameter -Wno-unused-variable build: rm -f *.o x86_64-elf-gcc -g -c -Isrc $(SOURCES) $(PROBLEMATIC_FLAGS) -Wall -Wextra -std=gnu99 -nostdlib -ffreestanding -fno-stack-protector -fno-omit-frame-pointer -fno-stack-check -fno-PIC -ffunction-sections -fdata-sections -mcmodel=kernel - objcopy -O elf64-x86-64 -B i386 -I binary zap-light16.psf zap-light16.o nasm -f elf64 src/idt/idt.S -o idt_stub.o - nasm -f elf64 src/entry.S -o entry.o x86_64-elf-ld -o pepperk -T linker.ld *.o nm -n pepperk | awk '$$2 ~ /[TtDdBbRr]/ {print $$1, $$3}' > symbols.map python3 symbols.py @@ -37,7 +35,7 @@ build-iso: limine/limine build ./limine/limine bios-install pepper.iso debug: - /usr/bin/qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -no-reboot -no-shutdown & + /usr/bin/qemu-system-x86_64 -drive file=pepper.iso -s -S -d int -D qemu.log -no-reboot -no-shutdown & gdb pepperk --command=debug.gdb debug2: diff --git a/debug.gdb b/debug.gdb index 2b97864..9712b3f 100644 --- a/debug.gdb +++ b/debug.gdb @@ -1,3 +1,7 @@ target remote localhost:1234 set disassembly-flavor intel display/4i $rip + +# Trying to debug that flanterm page fault + +# b plot_char_unscaled_uncanvas if $rdi == 0 || $rsi == 0 || $rdx == 0 || $r10 == 0 \ No newline at end of file diff --git a/linker.ld b/linker.ld index 5e3e8a6..1b34478 100644 --- a/linker.ld +++ b/linker.ld @@ -1,6 +1,6 @@ OUTPUT_FORMAT(elf64-x86-64) -ENTRY(_start) +ENTRY(kmain) PHDRS { diff --git a/src/config.h b/src/config.h index f403993..d243f93 100644 --- a/src/config.h +++ b/src/config.h @@ -11,7 +11,7 @@ #define PEPPEROS_VERSION_MAJOR "0" #define PEPPEROS_VERSION_MINOR "0" #define PEPPEROS_VERSION_PATCH "58" -#define PEPPEROS_SPLASH "pepperOS version "PEPPEROS_VERSION_MAJOR"."PEPPEROS_VERSION_MINOR"."PEPPEROS_VERSION_PATCH"\n" +#define PEPPEROS_SPLASH "\x1b[38;5;196mPepperOS\x1b[0m version "PEPPEROS_VERSION_MAJOR"."PEPPEROS_VERSION_MINOR"."PEPPEROS_VERSION_PATCH"\n" /* process */ #define PROCESS_NAME_MAX 64 @@ -30,7 +30,7 @@ #define KERNEL_STACK_SIZE 65536 /* heap */ -#define KHEAP_SIZE (16*1024*1024) +#define KHEAP_SIZE (32*1024*1024) /* term */ #define TERM_HISTORY_MAX_LINES 256 diff --git a/src/debug/misc.c b/src/debug/misc.c new file mode 100644 index 0000000..5cba142 --- /dev/null +++ b/src/debug/misc.c @@ -0,0 +1,61 @@ +#include +#include "limine.h" +#include "string/string.h" + +extern struct boot_context boot_ctx; + +// Display the memmap so we see how the memory is laid out at handoff +void memmap_display(struct limine_memmap_response* response) +{ + DEBUG("Got memory map from Limine: revision %u, %u entries", response->revision, response->entry_count); + + for (size_t i=0; ientry_count; i++) + { + struct limine_memmap_entry* entry = response->entries[i]; + char type[32] = {0}; + switch(entry->type) + { + case LIMINE_MEMMAP_USABLE: + strcpy(type, "USABLE"); + break; + case LIMINE_MEMMAP_RESERVED: + strcpy(type, "RESERVED"); + break; + case LIMINE_MEMMAP_ACPI_RECLAIMABLE: + strcpy(type, "ACPI_RECLAIMABLE"); + break; + case LIMINE_MEMMAP_ACPI_NVS: + strcpy(type, "ACPI_NVS"); + break; + case LIMINE_MEMMAP_BAD_MEMORY: + strcpy(type, "BAD_MEMORY"); + break; + case LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE: + strcpy(type, "BOOTLOADER_RECLAIMABLE"); + break; + case LIMINE_MEMMAP_KERNEL_AND_MODULES: + strcpy(type, "KERNEL_AND_MODULES"); + break; + case LIMINE_MEMMAP_FRAMEBUFFER: + strcpy(type, "FRAMEBUFFER"); + break; + default: + strcpy(type, "UNKNOWN"); + break; + } + DEBUG("entry %02u: [0x%016x | %016u bytes] - %s", i, entry->base, entry->length, type); + } +} + +// Display the HHDM +void hhdm_display(struct limine_hhdm_response* hhdm) +{ + DEBUG("Got HHDM revision=%u offset=0x%p", hhdm->revision, hhdm->offset); +} + +void boot_mem_display() +{ + memmap_display(boot_ctx.mmap); + hhdm_display(boot_ctx.hhdm); + DEBUG("kernel: phys_base=0x%p virt_base=0x%p", boot_ctx.kaddr->physical_base, boot_ctx.kaddr->virtual_base); +} \ No newline at end of file diff --git a/src/debug/panic.c b/src/debug/panic.c index 1a73a3d..53a50a8 100644 --- a/src/debug/panic.c +++ b/src/debug/panic.c @@ -9,13 +9,17 @@ void panic(struct cpu_status_t* ctx, const char* str) if (ctx == NULL) { DEBUG("\x1b[38;5;231m\x1b[48;5;196mKernel panic!!!\x1b[0m Something went horribly wrong! (no cpu ctx)"); + fctprintf((void*)&skputc, 0, "\x1b[38;5;231m\x1b[48;5;27m"); DIE_DEBUG(str); + fctprintf((void*)&skputc, 0, "\x1b[0m"); + skputc('\r'); skputc('\n'); DEBUG("\x1b[38;5;231m\x1b[48;5;196mend Kernel panic - halting...\x1b[0m"); hcf(); } - DEBUG("\x1b[38;5;231m\x1b[48;5;196mKernel panic!!!\x1b[0m at rip=%p\nSomething went horribly wrong! vect=0x%.2x errcode=0x%x\n\rrax=%p rbx=%p rcx=%p rdx=%p\n\rrsi=%p rdi=%p r8=%p r9=%p\n\rr10=%p r11=%p r12=%p r13=%p\n\rr14=%p r15=%p\n\n\rflags=%p\n\rHalting...", + DEBUG("\x1b[38;5;231m\x1b[48;5;196mKernel panic!!!\x1b[0m at rip=%p\r\nSomething went horribly wrong! (%s) vect=0x%.2x errcode=0x%x\n\rrax=%p rbx=%p rcx=%p rdx=%p\n\rrsi=%p rdi=%p r8=%p r9=%p\n\rr10=%p r11=%p r12=%p r13=%p\n\rr14=%p r15=%p\n\n\rflags=%p\n\rHalting...", ctx->iret_rip, + str, ctx->vector_number, ctx->error_code, ctx->rax, ctx->rbx, ctx->rcx, ctx->rdx, ctx->rsi, ctx->rdi, ctx->r8, ctx->r9, ctx->r10, ctx->r11, ctx->r12, ctx->r13, ctx->r14, ctx->r15, ctx->iret_flags); debug_stack_trace(100); diff --git a/src/entry.S b/src/entry.S deleted file mode 100644 index 73b6de0..0000000 --- a/src/entry.S +++ /dev/null @@ -1,23 +0,0 @@ -bits 64 -global _start - -extern kmain -extern kernel_stack - -KERNEL_STACK_SIZE equ 65536 - -section .text - -_start: - cli - - ; load kernel stack - lea rsp, [kernel_stack+KERNEL_STACK_SIZE] - - ; rbp=0 so last frame in stack trace - xor rbp, rbp - - ; 16 byte align - and rsp, -16 - - call kmain \ No newline at end of file diff --git a/src/idt/idt.c b/src/idt/idt.c index 7e559f4..34efe6b 100644 --- a/src/idt/idt.c +++ b/src/idt/idt.c @@ -203,9 +203,6 @@ struct cpu_status_t* interrupt_dispatch(struct cpu_status_t* context) if (ticks % SCHEDULER_QUANTUM == 0) { return scheduler_schedule(context); - //struct cpu_status_t* current_ctx = scheduler_schedule(context); - //process_switch(current_ctx->iret_rsp, current_ctx->iret_rip); - //SET_INTERRUPTS; } break; diff --git a/src/io/kbd/ps2.c b/src/io/kbd/ps2.c index 79d777e..65b1585 100644 --- a/src/io/kbd/ps2.c +++ b/src/io/kbd/ps2.c @@ -206,7 +206,7 @@ void keyboard_handler() if (c) { // Should probably have a keyboard buffer here... instead of this - putchar(c); + _putchar(c); } } } diff --git a/src/io/serial/serial.c b/src/io/serial/serial.c index 9073839..e2b9c57 100644 --- a/src/io/serial/serial.c +++ b/src/io/serial/serial.c @@ -42,7 +42,7 @@ int serial_init() // Set normal operation mode outb(PORT + 4, 0x0F); - DEBUG("serial initialized"); + DEBUG("*** Welcome to PepperOS! ***"); return 0; } diff --git a/src/io/term/flanterm.c b/src/io/term/flanterm.c new file mode 100644 index 0000000..0b9a31b --- /dev/null +++ b/src/io/term/flanterm.c @@ -0,0 +1,2129 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/* Copyright (C) 2022-2026 Mintsuki and contributors. + * + * 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 HOLDER 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. + */ + +#ifdef __cplusplus +#error "Please do not compile Flanterm as C++ code! Flanterm should be compiled as C99 or newer." +#endif + +#ifndef __STDC_VERSION__ +#error "Flanterm must be compiled as C99 or newer." +#endif + +#include +#include +#include + +#ifndef FLANTERM_IN_FLANTERM +#define FLANTERM_IN_FLANTERM +#endif + +#include "flanterm.h" + +// Tries to implement this standard for terminfo +// https://man7.org/linux/man-pages/man4/console_codes.4.html + +static const uint32_t col256[] = { + 0x000000, 0x00005f, 0x000087, 0x0000af, 0x0000d7, 0x0000ff, 0x005f00, 0x005f5f, + 0x005f87, 0x005faf, 0x005fd7, 0x005fff, 0x008700, 0x00875f, 0x008787, 0x0087af, + 0x0087d7, 0x0087ff, 0x00af00, 0x00af5f, 0x00af87, 0x00afaf, 0x00afd7, 0x00afff, + 0x00d700, 0x00d75f, 0x00d787, 0x00d7af, 0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f, + 0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff, 0x5f0000, 0x5f005f, 0x5f0087, 0x5f00af, + 0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f, 0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff, + 0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af, 0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f, + 0x5faf87, 0x5fafaf, 0x5fafd7, 0x5fafff, 0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af, + 0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f, 0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff, + 0x870000, 0x87005f, 0x870087, 0x8700af, 0x8700d7, 0x8700ff, 0x875f00, 0x875f5f, + 0x875f87, 0x875faf, 0x875fd7, 0x875fff, 0x878700, 0x87875f, 0x878787, 0x8787af, + 0x8787d7, 0x8787ff, 0x87af00, 0x87af5f, 0x87af87, 0x87afaf, 0x87afd7, 0x87afff, + 0x87d700, 0x87d75f, 0x87d787, 0x87d7af, 0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f, + 0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff, 0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af, + 0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f, 0xaf5f87, 0xaf5faf, 0xaf5fd7, 0xaf5fff, + 0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af, 0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f, + 0xafaf87, 0xafafaf, 0xafafd7, 0xafafff, 0xafd700, 0xafd75f, 0xafd787, 0xafd7af, + 0xafd7d7, 0xafd7ff, 0xafff00, 0xafff5f, 0xafff87, 0xafffaf, 0xafffd7, 0xafffff, + 0xd70000, 0xd7005f, 0xd70087, 0xd700af, 0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f, + 0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff, 0xd78700, 0xd7875f, 0xd78787, 0xd787af, + 0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f, 0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff, + 0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af, 0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f, + 0xd7ff87, 0xd7ffaf, 0xd7ffd7, 0xd7ffff, 0xff0000, 0xff005f, 0xff0087, 0xff00af, + 0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f, 0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff, + 0xff8700, 0xff875f, 0xff8787, 0xff87af, 0xff87d7, 0xff87ff, 0xffaf00, 0xffaf5f, + 0xffaf87, 0xffafaf, 0xffafd7, 0xffafff, 0xffd700, 0xffd75f, 0xffd787, 0xffd7af, + 0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f, 0xffff87, 0xffffaf, 0xffffd7, 0xffffff, + 0x080808, 0x121212, 0x1c1c1c, 0x262626, 0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e, + 0x585858, 0x626262, 0x6c6c6c, 0x767676, 0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e, + 0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6, 0xd0d0d0, 0xdadada, 0xe4e4e4, 0xeeeeee +}; + +#define CHARSET_DEFAULT 0 +#define CHARSET_DEC_SPECIAL 1 + +void flanterm_context_reinit(struct flanterm_context *ctx) { + ctx->tab_size = 8; + ctx->autoflush = true; + ctx->cursor_enabled = true; + ctx->scroll_enabled = true; + ctx->wrap_enabled = true; + ctx->origin_mode = false; + ctx->control_sequence = false; + ctx->escape = false; + ctx->osc = false; + ctx->osc_escape = false; + ctx->rrr = false; + ctx->discard_next = false; + ctx->bold = false; + ctx->bg_bold = false; + ctx->reverse_video = false; + ctx->dec_private = false; + ctx->insert_mode = false; + ctx->csi_unhandled = false; + ctx->unicode_remaining = 0; + ctx->g_select = 0; + ctx->charsets[0] = CHARSET_DEFAULT; + ctx->charsets[1] = CHARSET_DEC_SPECIAL; + ctx->current_charset = 0; + ctx->escape_offset = 0; + ctx->esc_values_i = 0; + ctx->saved_cursor_x = 0; + ctx->saved_cursor_y = 0; + ctx->current_primary = (size_t)-1; + ctx->current_bg = (size_t)-1; + ctx->saved_state_current_primary = (size_t)-1; + ctx->saved_state_current_bg = (size_t)-1; + ctx->last_printed_char = ' '; + ctx->last_was_graphic = false; + ctx->scroll_top_margin = 0; + ctx->scroll_bottom_margin = ctx->rows; +} + +static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c); + +void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) { + for (size_t i = 0; i < count; i++) { + flanterm_putchar(ctx, buf[i]); + } + + if (ctx->autoflush) { + ctx->double_buffer_flush(ctx); + } +} + +static void sgr(struct flanterm_context *ctx) { + size_t i = 0; + + if (!ctx->esc_values_i) + goto def; + + for (; i < ctx->esc_values_i; i++) { + size_t offset; + + if (ctx->esc_values[i] == 0) { +def: + if (ctx->reverse_video) { + ctx->reverse_video = false; + ctx->swap_palette(ctx); + } + ctx->bold = false; + ctx->bg_bold = false; + ctx->current_primary = (size_t)-1; + ctx->current_bg = (size_t)-1; + ctx->set_text_bg_default(ctx); + ctx->set_text_fg_default(ctx); + continue; + } + + else if (ctx->esc_values[i] == 1) { + ctx->bold = true; + if (ctx->current_primary == (size_t)-2) { + // RGB/256-color; bold does not alter the colour + } else if (ctx->current_primary != (size_t)-1) { + if (!ctx->reverse_video) { + ctx->set_text_fg_bright(ctx, ctx->current_primary); + } else { + ctx->set_text_bg_bright(ctx, ctx->current_primary); + } + } else { + if (!ctx->reverse_video) { + ctx->set_text_fg_default_bright(ctx); + } else { + ctx->set_text_bg_default_bright(ctx); + } + } + continue; + } + + else if (ctx->esc_values[i] == 2 + || ctx->esc_values[i] == 3 + || ctx->esc_values[i] == 4 + || ctx->esc_values[i] == 8) { + continue; + } + + else if (ctx->esc_values[i] == 5) { + ctx->bg_bold = true; + if (ctx->current_bg == (size_t)-2) { + // RGB/256-color; bold does not alter the colour + } else if (ctx->current_bg != (size_t)-1) { + if (!ctx->reverse_video) { + ctx->set_text_bg_bright(ctx, ctx->current_bg); + } else { + ctx->set_text_fg_bright(ctx, ctx->current_bg); + } + } else { + if (!ctx->reverse_video) { + ctx->set_text_bg_default_bright(ctx); + } else { + ctx->set_text_fg_default_bright(ctx); + } + } + continue; + } + + else if (ctx->esc_values[i] == 22) { + ctx->bold = false; + if (ctx->current_primary == (size_t)-2) { + // RGB/256-color; unbold does not alter the colour + } else if (ctx->current_primary != (size_t)-1) { + if (!ctx->reverse_video) { + ctx->set_text_fg(ctx, ctx->current_primary); + } else { + ctx->set_text_bg(ctx, ctx->current_primary); + } + } else { + if (!ctx->reverse_video) { + ctx->set_text_fg_default(ctx); + } else { + ctx->set_text_bg_default(ctx); + } + } + continue; + } + + else if (ctx->esc_values[i] == 23 + || ctx->esc_values[i] == 24 + || ctx->esc_values[i] == 28) { + continue; + } + + else if (ctx->esc_values[i] == 25) { + ctx->bg_bold = false; + if (ctx->current_bg == (size_t)-2) { + // RGB/256-color; unbold does not alter the colour + } else if (ctx->current_bg != (size_t)-1) { + if (!ctx->reverse_video) { + ctx->set_text_bg(ctx, ctx->current_bg); + } else { + ctx->set_text_fg(ctx, ctx->current_bg); + } + } else { + if (!ctx->reverse_video) { + ctx->set_text_bg_default(ctx); + } else { + ctx->set_text_fg_default(ctx); + } + } + continue; + } + + else if (ctx->esc_values[i] >= 30 && ctx->esc_values[i] <= 37) { + offset = 30; + ctx->current_primary = ctx->esc_values[i] - offset; + + if (ctx->reverse_video) { + goto set_bg; + } + +set_fg: + if ((ctx->bold && !ctx->reverse_video) + || (ctx->bg_bold && ctx->reverse_video)) { + ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset); + } else { + ctx->set_text_fg(ctx, ctx->esc_values[i] - offset); + } + continue; + } + + else if (ctx->esc_values[i] >= 40 && ctx->esc_values[i] <= 47) { + offset = 40; + ctx->current_bg = ctx->esc_values[i] - offset; + + if (ctx->reverse_video) { + goto set_fg; + } + +set_bg: + if ((ctx->bold && ctx->reverse_video) + || (ctx->bg_bold && !ctx->reverse_video)) { + ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset); + } else { + ctx->set_text_bg(ctx, ctx->esc_values[i] - offset); + } + continue; + } + + else if (ctx->esc_values[i] >= 90 && ctx->esc_values[i] <= 97) { + offset = 90; + ctx->current_primary = ctx->esc_values[i] - offset; + + if (ctx->reverse_video) { + goto set_bg_bright; + } + +set_fg_bright: + ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset); + continue; + } + + else if (ctx->esc_values[i] >= 100 && ctx->esc_values[i] <= 107) { + offset = 100; + ctx->current_bg = ctx->esc_values[i] - offset; + + if (ctx->reverse_video) { + goto set_fg_bright; + } + +set_bg_bright: + ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset); + continue; + } + + else if (ctx->esc_values[i] == 39) { + ctx->current_primary = (size_t)-1; + + if (ctx->reverse_video) { + ctx->swap_palette(ctx); + } + + if (!ctx->bold) { + ctx->set_text_fg_default(ctx); + } else { + ctx->set_text_fg_default_bright(ctx); + } + + if (ctx->reverse_video) { + ctx->swap_palette(ctx); + } + + continue; + } + + else if (ctx->esc_values[i] == 49) { + ctx->current_bg = (size_t)-1; + + if (ctx->reverse_video) { + ctx->swap_palette(ctx); + } + + if (!ctx->bg_bold) { + ctx->set_text_bg_default(ctx); + } else { + ctx->set_text_bg_default_bright(ctx); + } + + if (ctx->reverse_video) { + ctx->swap_palette(ctx); + } + + continue; + } + + else if (ctx->esc_values[i] == 7) { + if (!ctx->reverse_video) { + ctx->reverse_video = true; + ctx->swap_palette(ctx); + } + continue; + } + + else if (ctx->esc_values[i] == 27) { + if (ctx->reverse_video) { + ctx->reverse_video = false; + ctx->swap_palette(ctx); + } + continue; + } + + // 256/RGB + else if (ctx->esc_values[i] == 38 || ctx->esc_values[i] == 48) { + bool fg = ctx->esc_values[i] == 38; + + if (ctx->reverse_video) { + fg = !fg; + } + + i++; + if (i >= ctx->esc_values_i) { + break; + } + + switch (ctx->esc_values[i]) { + case 2: { // RGB + if (i + 3 >= ctx->esc_values_i) { + goto out; + } + + uint32_t rgb_value = 0; + + rgb_value |= (ctx->esc_values[i + 1] & 0xff) << 16; + rgb_value |= (ctx->esc_values[i + 2] & 0xff) << 8; + rgb_value |= (ctx->esc_values[i + 3] & 0xff); + + i += 3; + + if (fg) { + ctx->current_primary = (size_t)-2; + } else { + ctx->current_bg = (size_t)-2; + } + + (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value); + + break; + } + case 5: { // 256 colors + if (i + 1 >= ctx->esc_values_i) { + goto out; + } + + uint32_t col = ctx->esc_values[i + 1]; + + i++; + + if (col < 8) { + if (fg) { + ctx->current_primary = col; + } else { + ctx->current_bg = col; + } + (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col); + } else if (col < 16) { + if (fg) { + ctx->current_primary = col - 8; + } else { + ctx->current_bg = col - 8; + } + (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8); + } else if (col < 256) { + if (fg) { + ctx->current_primary = (size_t)-2; + } else { + ctx->current_bg = (size_t)-2; + } + uint32_t rgb_value = col256[col - 16]; + (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value); + } + + break; + } + default: continue; + } + } + } + +out:; +} + +static void dec_private_parse(struct flanterm_context *ctx, uint8_t c) { + ctx->dec_private = false; + + if (ctx->esc_values_i == 0) { + return; + } + + bool set; + + switch (c) { + case 'h': + set = true; break; + case 'l': + set = false; break; + default: + return; + } + + for (size_t i = 0; i < ctx->esc_values_i; i++) { + switch (ctx->esc_values[i]) { + case 6: + ctx->origin_mode = set; + ctx->set_cursor_pos(ctx, 0, set ? ctx->scroll_top_margin : 0); + break; + case 7: + ctx->wrap_enabled = set; + break; + case 25: + ctx->cursor_enabled = set; + break; + case 1049: + if (set) { + ctx->clear(ctx, true); + } else { + if (ctx->reverse_video) { + ctx->reverse_video = false; + ctx->swap_palette(ctx); + } + ctx->bold = false; + ctx->bg_bold = false; + ctx->current_primary = (size_t)-1; + ctx->current_bg = (size_t)-1; + ctx->set_text_bg_default(ctx); + ctx->set_text_fg_default(ctx); + ctx->clear(ctx, true); + } + break; + } + } + + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c); + } +} + +static void linux_private_parse(struct flanterm_context *ctx) { + if (ctx->esc_values_i == 0) { + return; + } + + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0); + } +} + +static void mode_toggle(struct flanterm_context *ctx, uint8_t c) { + if (ctx->esc_values_i == 0) { + return; + } + + bool set; + + switch (c) { + case 'h': + set = true; break; + case 'l': + set = false; break; + default: + return; + } + + switch (ctx->esc_values[0]) { + case 4: + ctx->insert_mode = set; return; + } + + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c); + } +} + +static void osc_finalize(struct flanterm_context *ctx) { + if (ctx->callback != NULL) { + // Parse the leading OSC number and skip past the semicolon. + uint64_t osc_num = 0; + size_t i = 0; + while (i < ctx->osc_buf_i && ctx->osc_buf[i] >= '0' && ctx->osc_buf[i] <= '9') { + osc_num = osc_num * 10 + (ctx->osc_buf[i] - '0'); + i++; + } + if (i < ctx->osc_buf_i && ctx->osc_buf[i] == ';') { + i++; + } + ctx->callback(ctx, FLANTERM_CB_OSC, osc_num, ctx->osc_buf_i - i, (uintptr_t)&ctx->osc_buf[i]); + } +} + +static bool osc_parse(struct flanterm_context *ctx, uint8_t c) { + // ESC \ terminates an OSC sequence cleanly + // but if ESC is followed by non-\, report failure from osc_parse and + // try parsing the character as another escape code + if (ctx->osc_escape) { + if (c == '\\') { + osc_finalize(ctx); + ctx->osc = false; + ctx->osc_escape = false; + ctx->escape = false; + return true; + } else { + ctx->osc_escape = false; + ctx->osc = false; + // escape stays true here + return false; + } + } + switch (c) { + case 0x1b: + ctx->osc_escape = true; + break; + // BEL is the other terminator + case '\a': + osc_finalize(ctx); + ctx->osc_escape = false; + ctx->osc = false; + ctx->escape = false; + break; + default: + if (ctx->osc_buf_i < sizeof(ctx->osc_buf)) { + ctx->osc_buf[ctx->osc_buf_i++] = c; + } + break; + } + return true; +} + +static void control_sequence_parse(struct flanterm_context *ctx, uint8_t c) { + if (ctx->escape_offset == 2) { + switch (c) { + case '[': + ctx->discard_next = true; + goto cleanup; + case '?': + ctx->dec_private = true; + return; + } + } + + // C0 control characters are executed immediately within CSI sequences + // (except ESC which is handled later, and CAN/SUB which are handled by the caller) + if (c < 0x20 && c != 0x1b) { + size_t x, y; + switch (c) { + case '\a': + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0); + } + break; + case '\b': + ctx->get_cursor_pos(ctx, &x, &y); + if (x > 0) { + ctx->set_cursor_pos(ctx, x - 1, y); + } + break; + case '\t': + ctx->get_cursor_pos(ctx, &x, &y); + x = (x / ctx->tab_size + 1) * ctx->tab_size; + if (x >= ctx->cols) { + x = ctx->cols - 1; + } + ctx->set_cursor_pos(ctx, x, y); + break; + case 0x0b: + case 0x0c: + case '\n': + ctx->get_cursor_pos(ctx, &x, &y); + if (y == ctx->scroll_bottom_margin - 1) { + ctx->scroll(ctx); + ctx->set_cursor_pos(ctx, x, y); + } else { + ctx->set_cursor_pos(ctx, x, y + 1); + } + break; + case '\r': + ctx->get_cursor_pos(ctx, &x, &y); + ctx->set_cursor_pos(ctx, 0, y); + break; + case 14: + ctx->current_charset = 1; + break; + case 15: + ctx->current_charset = 0; + break; + default: + break; + } + return; + } + + if (c >= '0' && c <= '9') { + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { + return; + } + ctx->rrr = true; + if (ctx->esc_values[ctx->esc_values_i] > UINT32_MAX / 10) { + return; + } + ctx->esc_values[ctx->esc_values_i] *= 10; + ctx->esc_values[ctx->esc_values_i] += c - '0'; + return; + } + + if (ctx->rrr == true) { + ctx->esc_values_i++; + ctx->rrr = false; + if (c == ';') + return; + } else if (c == ';') { + if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) { + return; + } + ctx->esc_values[ctx->esc_values_i] = 0; + ctx->esc_values_i++; + return; + } + + size_t esc_default; + switch (c) { + case 'J': case 'K': case 'q': case 'm': case 'c': case ']': + esc_default = 0; break; + default: + esc_default = 1; break; + } + + for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) { + ctx->esc_values[i] = esc_default; + } + + if (esc_default != 0) { + for (size_t i = 0; i < ctx->esc_values_i; i++) { + if (ctx->esc_values[i] == 0) { + ctx->esc_values[i] = esc_default; + } + } + } + + if (ctx->dec_private == true) { + dec_private_parse(ctx, c); + goto cleanup; + } + + // CSI sequences are terminated by a byte in [0x40,0x7E] + // so skip all bytes until the terminator byte + if (ctx->csi_unhandled) { + if (c >= 0x40 && c <= 0x7E) { + ctx->csi_unhandled = false; + goto cleanup; + } + return; + } + + bool r = ctx->scroll_enabled; + ctx->scroll_enabled = false; + size_t x, y; + ctx->get_cursor_pos(ctx, &x, &y); + + switch (c) { + // ESC aborts the current CSI and starts a new escape sequence + case 0x1B: + ctx->scroll_enabled = r; + ctx->control_sequence = false; + ctx->escape_offset = 0; + return; + case 'F': + x = 0; + // FALLTHRU + case 'A': { + if (ctx->esc_values[0] > y) + ctx->esc_values[0] = y; + size_t dest_y = y - ctx->esc_values[0]; + size_t min_y = ctx->origin_mode ? ctx->scroll_top_margin : 0; + if (dest_y < min_y) { + dest_y = min_y; + } + ctx->set_cursor_pos(ctx, x, dest_y); + break; + } + case 'E': + x = 0; + // FALLTHRU + case 'e': + case 'B': { + if (y + ctx->esc_values[0] > ctx->rows - 1) + ctx->esc_values[0] = (ctx->rows - 1) - y; + size_t dest_y = y + ctx->esc_values[0]; + size_t max_y = ctx->origin_mode ? ctx->scroll_bottom_margin : ctx->rows; + if (dest_y >= max_y) { + dest_y = max_y - 1; + } + ctx->set_cursor_pos(ctx, x, dest_y); + break; + } + case 'a': + case 'C': + if (x + ctx->esc_values[0] > ctx->cols - 1) + ctx->esc_values[0] = (ctx->cols - 1) - x; + ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y); + break; + case 'D': + if (ctx->esc_values[0] > x) + ctx->esc_values[0] = x; + ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y); + break; + case 'c': + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0); + } + break; + case 'd': { + if (ctx->esc_values[0] != 0) { + ctx->esc_values[0]--; + } + size_t max_row = ctx->rows; + size_t row_offset = 0; + if (ctx->origin_mode) { + max_row = ctx->scroll_bottom_margin - ctx->scroll_top_margin; + row_offset = ctx->scroll_top_margin; + } + if (ctx->esc_values[0] >= max_row) + ctx->esc_values[0] = max_row - 1; + ctx->set_cursor_pos(ctx, x, ctx->esc_values[0] + row_offset); + break; + } + case 'G': + case '`': + if (ctx->esc_values[0] != 0) { + ctx->esc_values[0]--; + } + if (ctx->esc_values[0] >= ctx->cols) + ctx->esc_values[0] = ctx->cols - 1; + ctx->set_cursor_pos(ctx, ctx->esc_values[0], y); + break; + case 'H': + case 'f': { + if (ctx->esc_values[0] != 0) { + ctx->esc_values[0]--; + } + if (ctx->esc_values[1] != 0) { + ctx->esc_values[1]--; + } + size_t max_row = ctx->rows; + size_t row_offset = 0; + if (ctx->origin_mode) { + max_row = ctx->scroll_bottom_margin - ctx->scroll_top_margin; + row_offset = ctx->scroll_top_margin; + } + if (ctx->esc_values[1] >= ctx->cols) { + ctx->esc_values[1] = ctx->cols - 1; + } + if (ctx->esc_values[0] >= max_row) { + ctx->esc_values[0] = max_row - 1; + } + ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0] + row_offset); + break; + } + case 'M': { + if (y < ctx->scroll_top_margin || y >= ctx->scroll_bottom_margin) { + break; + } + size_t old_scroll_top_margin = ctx->scroll_top_margin; + ctx->scroll_top_margin = y; + size_t max_count = ctx->scroll_bottom_margin - y; + size_t count = ctx->esc_values[0] > max_count ? max_count : ctx->esc_values[0]; + for (size_t i = 0; i < count; i++) { + ctx->scroll(ctx); + } + ctx->scroll_top_margin = old_scroll_top_margin; + break; + } + case 'L': { + if (y < ctx->scroll_top_margin || y >= ctx->scroll_bottom_margin) { + break; + } + size_t old_scroll_top_margin = ctx->scroll_top_margin; + ctx->scroll_top_margin = y; + size_t max_count = ctx->scroll_bottom_margin - y; + size_t count = ctx->esc_values[0] > max_count ? max_count : ctx->esc_values[0]; + for (size_t i = 0; i < count; i++) { + ctx->revscroll(ctx); + } + ctx->scroll_top_margin = old_scroll_top_margin; + break; + } + case 'n': + switch (ctx->esc_values[0]) { + case 5: + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0); + } + break; + case 6: + if (ctx->callback != NULL) { + size_t report_y = ctx->origin_mode && y >= ctx->scroll_top_margin + ? y - ctx->scroll_top_margin : y; + ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, report_y + 1, 0); + } + break; + } + break; + case 'q': + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0); + } + break; + case 'J': + switch (ctx->esc_values[0]) { + case 0: { + // Erase from cursor to end: clear rest of current line, + // then clear full lines below, using explicit cursor + // positioning to avoid scroll region wrapping limits. + ctx->set_cursor_pos(ctx, x, y); + for (size_t xc = x; xc < ctx->cols; xc++) { + ctx->raw_putchar(ctx, ' '); + } + for (size_t yc = y + 1; yc < ctx->rows; yc++) { + ctx->set_cursor_pos(ctx, 0, yc); + for (size_t xc = 0; xc < ctx->cols; xc++) { + ctx->raw_putchar(ctx, ' '); + } + } + ctx->set_cursor_pos(ctx, x, y); + break; + } + case 1: { + // Erase from start to cursor: clear full lines above, + // then clear current line up to and including cursor. + for (size_t yc = 0; yc < y; yc++) { + ctx->set_cursor_pos(ctx, 0, yc); + for (size_t xc = 0; xc < ctx->cols; xc++) { + ctx->raw_putchar(ctx, ' '); + } + } + ctx->set_cursor_pos(ctx, 0, y); + for (size_t xc = 0; xc <= x; xc++) { + ctx->raw_putchar(ctx, ' '); + } + ctx->set_cursor_pos(ctx, x, y); + break; + } + case 2: + case 3: + ctx->clear(ctx, false); + break; + } + break; + case '@': { + size_t n = ctx->esc_values[0]; + if (n > ctx->cols - x) { + n = ctx->cols - x; + } + for (size_t i = ctx->cols - 1; i >= x + n; i--) { + ctx->move_character(ctx, i, y, i - n, y); + } + ctx->set_cursor_pos(ctx, x, y); + for (size_t i = 0; i < n; i++) { + ctx->raw_putchar(ctx, ' '); + } + ctx->set_cursor_pos(ctx, x, y); + break; + } + case 'P': + if (ctx->esc_values[0] > ctx->cols - x) + ctx->esc_values[0] = ctx->cols - x; + for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++) + ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y); + ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y); + // FALLTHRU + case 'X': { + size_t cx, cy; + ctx->get_cursor_pos(ctx, &cx, &cy); + ctx->set_cursor_pos(ctx, cx, cy); + size_t remaining = ctx->cols - cx; + size_t count = ctx->esc_values[0] > remaining ? remaining : ctx->esc_values[0]; + for (size_t i = 0; i < count; i++) + ctx->raw_putchar(ctx, ' '); + ctx->set_cursor_pos(ctx, x, y); + break; + } + case 'm': + sgr(ctx); + break; + case 's': + ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y); + break; + case 'u': + ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y); + break; + case 'K': + switch (ctx->esc_values[0]) { + case 0: { + ctx->set_cursor_pos(ctx, x, y); + for (size_t i = x; i < ctx->cols; i++) + ctx->raw_putchar(ctx, ' '); + ctx->set_cursor_pos(ctx, x, y); + break; + } + case 1: { + ctx->set_cursor_pos(ctx, 0, y); + for (size_t i = 0; i <= x; i++) + ctx->raw_putchar(ctx, ' '); + ctx->set_cursor_pos(ctx, x, y); + break; + } + case 2: { + ctx->set_cursor_pos(ctx, 0, y); + for (size_t i = 0; i < ctx->cols; i++) + ctx->raw_putchar(ctx, ' '); + ctx->set_cursor_pos(ctx, x, y); + break; + } + } + break; + case 'r': + ctx->scroll_top_margin = 0; + ctx->scroll_bottom_margin = ctx->rows; + if (ctx->esc_values_i > 0) { + ctx->scroll_top_margin = ctx->esc_values[0] - 1; + } + if (ctx->esc_values_i > 1) { + ctx->scroll_bottom_margin = ctx->esc_values[1]; + } + if (ctx->scroll_top_margin >= ctx->rows + || ctx->scroll_bottom_margin > ctx->rows + || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) { + ctx->scroll_top_margin = 0; + ctx->scroll_bottom_margin = ctx->rows; + } + ctx->set_cursor_pos(ctx, 0, ctx->origin_mode ? ctx->scroll_top_margin : 0); + break; + case 'l': + case 'h': + mode_toggle(ctx, c); + break; + case 'S': { + size_t region = ctx->scroll_bottom_margin - ctx->scroll_top_margin; + size_t count = ctx->esc_values[0] > region ? region : ctx->esc_values[0]; + for (size_t i = 0; i < count; i++) { + ctx->scroll(ctx); + } + break; + } + case 'T': { + size_t region = ctx->scroll_bottom_margin - ctx->scroll_top_margin; + size_t count = ctx->esc_values[0] > region ? region : ctx->esc_values[0]; + for (size_t i = 0; i < count; i++) { + ctx->revscroll(ctx); + } + break; + } + case 'b': { + if (!ctx->last_was_graphic) { + break; + } + ctx->scroll_enabled = r; + size_t count = ctx->esc_values[0] > 65535 ? 65535 : ctx->esc_values[0]; + for (size_t i = 0; i < count; i++) { + if (ctx->insert_mode == true) { + size_t ix, iy; + ctx->get_cursor_pos(ctx, &ix, &iy); + for (size_t j = ctx->cols - 1; j > ix; j--) { + ctx->move_character(ctx, j, iy, j - 1, iy); + } + } + ctx->raw_putchar(ctx, ctx->last_printed_char); + } + break; + } + case ']': + linux_private_parse(ctx); + break; + default: + if (c >= 0x40 && c <= 0x7E) { + break; + } + ctx->scroll_enabled = r; + ctx->csi_unhandled = true; + return; + } + + ctx->scroll_enabled = r; + +cleanup: + ctx->control_sequence = false; + ctx->escape = false; +} + +static void restore_state(struct flanterm_context *ctx) { + ctx->bold = ctx->saved_state_bold; + ctx->bg_bold = ctx->saved_state_bg_bold; + ctx->reverse_video = ctx->saved_state_reverse_video; + ctx->origin_mode = ctx->saved_state_origin_mode; + ctx->wrap_enabled = ctx->saved_state_wrap_enabled; + ctx->current_charset = ctx->saved_state_current_charset; + ctx->charsets[0] = ctx->saved_state_charsets[0]; + ctx->charsets[1] = ctx->saved_state_charsets[1]; + ctx->current_primary = ctx->saved_state_current_primary; + ctx->current_bg = ctx->saved_state_current_bg; + + ctx->restore_state(ctx); +} + +static void save_state(struct flanterm_context *ctx) { + ctx->save_state(ctx); + + ctx->saved_state_bold = ctx->bold; + ctx->saved_state_bg_bold = ctx->bg_bold; + ctx->saved_state_reverse_video = ctx->reverse_video; + ctx->saved_state_origin_mode = ctx->origin_mode; + ctx->saved_state_wrap_enabled = ctx->wrap_enabled; + ctx->saved_state_current_charset = ctx->current_charset; + ctx->saved_state_charsets[0] = ctx->charsets[0]; + ctx->saved_state_charsets[1] = ctx->charsets[1]; + ctx->saved_state_current_primary = ctx->current_primary; + ctx->saved_state_current_bg = ctx->current_bg; +} + +static void escape_parse(struct flanterm_context *ctx, uint8_t c) { + ctx->escape_offset++; + + if (ctx->osc == true) { + // ESC \ is one of the two possible terminators of OSC sequences, + // so osc_parse consumes ESC. + // If it is then followed by \ it cleans correctly, + // otherwise it returns false, and it tries parsing it as another escape sequence + if (osc_parse(ctx, c)) { + return; + } + // OSC aborted by ESC + non-backslash; reset offset for new sequence + ctx->escape_offset = 1; + } + + if (ctx->control_sequence == true) { + control_sequence_parse(ctx, c); + return; + } + + size_t x, y; + ctx->get_cursor_pos(ctx, &x, &y); + + switch (c) { + case 0x1b: + ctx->escape_offset = 0; + return; + case ']': + ctx->osc_escape = false; + ctx->osc = true; + ctx->osc_buf_i = 0; + return; + case '[': + for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++) + ctx->esc_values[i] = 0; + ctx->esc_values_i = 0; + ctx->rrr = false; + ctx->csi_unhandled = false; + ctx->control_sequence = true; + return; + case '7': + save_state(ctx); + break; + case '8': + restore_state(ctx); + break; + case 'c': + if (ctx->reverse_video) { + ctx->swap_palette(ctx); + } + flanterm_context_reinit(ctx); + ctx->set_text_bg_default(ctx); + ctx->set_text_fg_default(ctx); + ctx->clear(ctx, true); + break; + case 'D': + if (y == ctx->scroll_bottom_margin - 1) { + ctx->scroll(ctx); + ctx->set_cursor_pos(ctx, x, y); + } else if (y < ctx->rows - 1) { + ctx->set_cursor_pos(ctx, x, y + 1); + } + break; + case 'E': + if (y == ctx->scroll_bottom_margin - 1) { + ctx->scroll(ctx); + ctx->set_cursor_pos(ctx, 0, y); + } else if (y < ctx->rows - 1) { + ctx->set_cursor_pos(ctx, 0, y + 1); + } else { + ctx->set_cursor_pos(ctx, 0, y); + } + break; + case 'M': + // "Reverse linefeed" + if (y == ctx->scroll_top_margin) { + ctx->revscroll(ctx); + ctx->set_cursor_pos(ctx, x, y); + } else if (y > 0) { + ctx->set_cursor_pos(ctx, x, y - 1); + } + break; + case 'Z': + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0); + } + break; + case '(': + case ')': + ctx->g_select = c - '\''; + break; + } + + ctx->escape = false; +} + +static bool dec_special_print(struct flanterm_context *ctx, uint8_t c) { +#define FLANTERM_DEC_SPCL_PRN(C) ctx->last_printed_char = (C); ctx->last_was_graphic = true; ctx->raw_putchar(ctx, (C)); return true; + switch (c) { + case '`': FLANTERM_DEC_SPCL_PRN(0x04) + case '0': FLANTERM_DEC_SPCL_PRN(0xdb) + case '-': FLANTERM_DEC_SPCL_PRN(0x18) + case ',': FLANTERM_DEC_SPCL_PRN(0x1b) + case '.': FLANTERM_DEC_SPCL_PRN(0x19) + case 'a': FLANTERM_DEC_SPCL_PRN(0xb1) + case 'f': FLANTERM_DEC_SPCL_PRN(0xf8) + case 'g': FLANTERM_DEC_SPCL_PRN(0xf1) + case 'h': FLANTERM_DEC_SPCL_PRN(0xb0) + case 'j': FLANTERM_DEC_SPCL_PRN(0xd9) + case 'k': FLANTERM_DEC_SPCL_PRN(0xbf) + case 'l': FLANTERM_DEC_SPCL_PRN(0xda) + case 'm': FLANTERM_DEC_SPCL_PRN(0xc0) + case 'n': FLANTERM_DEC_SPCL_PRN(0xc5) + case 'q': FLANTERM_DEC_SPCL_PRN(0xc4) + case 's': FLANTERM_DEC_SPCL_PRN(0x5f) + case 't': FLANTERM_DEC_SPCL_PRN(0xc3) + case 'u': FLANTERM_DEC_SPCL_PRN(0xb4) + case 'v': FLANTERM_DEC_SPCL_PRN(0xc1) + case 'w': FLANTERM_DEC_SPCL_PRN(0xc2) + case 'x': FLANTERM_DEC_SPCL_PRN(0xb3) + case 'y': FLANTERM_DEC_SPCL_PRN(0xf3) + case 'z': FLANTERM_DEC_SPCL_PRN(0xf2) + case '~': FLANTERM_DEC_SPCL_PRN(0xfa) + case '_': FLANTERM_DEC_SPCL_PRN(0xff) + case '+': FLANTERM_DEC_SPCL_PRN(0x1a) + case '{': FLANTERM_DEC_SPCL_PRN(0xe3) + case '}': FLANTERM_DEC_SPCL_PRN(0x9c) + } +#undef FLANTERM_DEC_SPCL_PRN + + return false; +} + +// Following wcwidth related code inherited from: +// https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c + +struct interval { + uint32_t first; + uint32_t last; +}; + +/* auxiliary function for binary search in interval table */ +static int bisearch(uint32_t ucs, const struct interval *table, int max) { + int min = 0; + int mid; + + if (ucs < table[0].first || ucs > table[max].last) + return 0; + while (max >= min) { + mid = (min + max) / 2; + if (ucs > table[mid].last) + min = mid + 1; + else if (ucs < table[mid].first) + max = mid - 1; + else + return 1; + } + + return 0; +} + +static int mk_wcwidth(uint32_t ucs) { + /* sorted list of non-overlapping intervals of zero-width characters */ + /* Unicode 17.0.0 */ + static const struct interval combining[] = { + { 0x0300, 0x036F }, { 0x0483, 0x0489 }, { 0x0591, 0x05BD }, + { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, { 0x05C4, 0x05C5 }, + { 0x05C7, 0x05C7 }, { 0x0610, 0x061A }, { 0x061C, 0x061C }, + { 0x064B, 0x065F }, { 0x0670, 0x0670 }, { 0x06D6, 0x06DC }, + { 0x06DF, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, + { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 }, + { 0x07EB, 0x07F3 }, { 0x07FD, 0x07FD }, { 0x0816, 0x0819 }, + { 0x081B, 0x0823 }, { 0x0825, 0x0827 }, { 0x0829, 0x082D }, + { 0x0859, 0x085B }, { 0x0897, 0x089F }, { 0x08CA, 0x08E1 }, + { 0x08E3, 0x0902 }, { 0x093A, 0x093A }, { 0x093C, 0x093C }, + { 0x0941, 0x0948 }, { 0x094D, 0x094D }, { 0x0951, 0x0957 }, + { 0x0962, 0x0963 }, { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, + { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, + { 0x09FE, 0x09FE }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C }, + { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D }, + { 0x0A51, 0x0A51 }, { 0x0A70, 0x0A71 }, { 0x0A75, 0x0A75 }, + { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, + { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD }, { 0x0AE2, 0x0AE3 }, + { 0x0AFA, 0x0AFF }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C }, + { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B44 }, { 0x0B4D, 0x0B4D }, + { 0x0B55, 0x0B56 }, { 0x0B62, 0x0B63 }, { 0x0B82, 0x0B82 }, + { 0x0BC0, 0x0BC0 }, { 0x0BCD, 0x0BCD }, { 0x0C00, 0x0C00 }, + { 0x0C04, 0x0C04 }, { 0x0C3C, 0x0C3C }, { 0x0C3E, 0x0C40 }, + { 0x0C46, 0x0C48 }, { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, + { 0x0C62, 0x0C63 }, { 0x0C81, 0x0C81 }, { 0x0CBC, 0x0CBC }, + { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, + { 0x0CE2, 0x0CE3 }, { 0x0D00, 0x0D01 }, { 0x0D3B, 0x0D3C }, + { 0x0D41, 0x0D44 }, { 0x0D4D, 0x0D4D }, { 0x0D62, 0x0D63 }, + { 0x0D81, 0x0D81 }, { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, + { 0x0DD6, 0x0DD6 }, { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, + { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EBC }, + { 0x0EC8, 0x0ECE }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, + { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E }, + { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F8D, 0x0F97 }, + { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 }, + { 0x1032, 0x1037 }, { 0x1039, 0x103A }, { 0x103D, 0x103E }, + { 0x1058, 0x1059 }, { 0x105E, 0x1060 }, { 0x1071, 0x1074 }, + { 0x1082, 0x1082 }, { 0x1085, 0x1086 }, { 0x108D, 0x108D }, + { 0x109D, 0x109D }, { 0x1160, 0x11FF }, { 0x135D, 0x135F }, + { 0x1712, 0x1714 }, { 0x1732, 0x1733 }, { 0x1752, 0x1753 }, + { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, + { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, + { 0x180B, 0x180F }, { 0x1885, 0x1886 }, { 0x18A9, 0x18A9 }, + { 0x1920, 0x1922 }, { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, + { 0x1939, 0x193B }, { 0x1A17, 0x1A18 }, { 0x1A1B, 0x1A1B }, + { 0x1A56, 0x1A56 }, { 0x1A58, 0x1A5E }, { 0x1A60, 0x1A60 }, + { 0x1A62, 0x1A62 }, { 0x1A65, 0x1A6C }, { 0x1A73, 0x1A7C }, + { 0x1A7F, 0x1A7F }, { 0x1AB0, 0x1ADD }, { 0x1AE0, 0x1AEB }, + { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 }, { 0x1B36, 0x1B3A }, + { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 }, { 0x1B6B, 0x1B73 }, + { 0x1B80, 0x1B81 }, { 0x1BA2, 0x1BA5 }, { 0x1BA8, 0x1BA9 }, + { 0x1BAB, 0x1BAD }, { 0x1BE6, 0x1BE6 }, { 0x1BE8, 0x1BE9 }, + { 0x1BED, 0x1BED }, { 0x1BEF, 0x1BF1 }, { 0x1C2C, 0x1C33 }, + { 0x1C36, 0x1C37 }, { 0x1CD0, 0x1CD2 }, { 0x1CD4, 0x1CE0 }, + { 0x1CE2, 0x1CE8 }, { 0x1CED, 0x1CED }, { 0x1CF4, 0x1CF4 }, + { 0x1CF8, 0x1CF9 }, { 0x1DC0, 0x1DFF }, { 0x200B, 0x200F }, + { 0x2028, 0x202E }, { 0x2060, 0x206F }, { 0x20D0, 0x20F0 }, + { 0x2CEF, 0x2CF1 }, { 0x2D7F, 0x2D7F }, { 0x2DE0, 0x2DFF }, + { 0x302A, 0x302D }, { 0x3099, 0x309A }, { 0x3164, 0x3164 }, + { 0xA66F, 0xA672 }, { 0xA674, 0xA67D }, { 0xA69E, 0xA69F }, + { 0xA6F0, 0xA6F1 }, { 0xA802, 0xA802 }, { 0xA806, 0xA806 }, + { 0xA80B, 0xA80B }, { 0xA825, 0xA826 }, { 0xA82C, 0xA82C }, + { 0xA8C4, 0xA8C5 }, { 0xA8E0, 0xA8F1 }, { 0xA8FF, 0xA8FF }, + { 0xA926, 0xA92D }, { 0xA947, 0xA951 }, { 0xA980, 0xA982 }, + { 0xA9B3, 0xA9B3 }, { 0xA9B6, 0xA9B9 }, { 0xA9BC, 0xA9BD }, + { 0xA9E5, 0xA9E5 }, { 0xAA29, 0xAA2E }, { 0xAA31, 0xAA32 }, + { 0xAA35, 0xAA36 }, { 0xAA43, 0xAA43 }, { 0xAA4C, 0xAA4C }, + { 0xAA7C, 0xAA7C }, { 0xAAB0, 0xAAB0 }, { 0xAAB2, 0xAAB4 }, + { 0xAAB7, 0xAAB8 }, { 0xAABE, 0xAABF }, { 0xAAC1, 0xAAC1 }, + { 0xAAEC, 0xAAED }, { 0xAAF6, 0xAAF6 }, { 0xABE5, 0xABE5 }, + { 0xABE8, 0xABE8 }, { 0xABED, 0xABED }, { 0xD7B0, 0xD7FF }, + { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE2F }, + { 0xFEFF, 0xFEFF }, { 0xFFA0, 0xFFA0 }, { 0xFFF0, 0xFFFB }, + { 0x101FD, 0x101FD }, { 0x102E0, 0x102E0 }, { 0x10376, 0x1037A }, + { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F }, + { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x10AE5, 0x10AE6 }, + { 0x10D24, 0x10D27 }, { 0x10D69, 0x10D6D }, { 0x10EAB, 0x10EAC }, + { 0x10EFA, 0x10EFF }, { 0x10F46, 0x10F50 }, { 0x10F82, 0x10F85 }, + { 0x11001, 0x11001 }, { 0x11038, 0x11046 }, { 0x11070, 0x11070 }, + { 0x11073, 0x11074 }, { 0x1107F, 0x11081 }, { 0x110B3, 0x110B6 }, + { 0x110B9, 0x110BA }, { 0x110C2, 0x110C2 }, { 0x11100, 0x11102 }, + { 0x11127, 0x1112B }, { 0x1112D, 0x11134 }, { 0x11173, 0x11173 }, + { 0x11180, 0x11181 }, { 0x111B6, 0x111BE }, { 0x111C9, 0x111CC }, + { 0x111CF, 0x111CF }, { 0x1122F, 0x11231 }, { 0x11234, 0x11234 }, + { 0x11236, 0x11237 }, { 0x1123E, 0x1123E }, { 0x11241, 0x11241 }, + { 0x112DF, 0x112DF }, { 0x112E3, 0x112EA }, { 0x11300, 0x11301 }, + { 0x1133B, 0x1133C }, { 0x11340, 0x11340 }, { 0x11366, 0x1136C }, + { 0x11370, 0x11374 }, { 0x113BB, 0x113C0 }, { 0x113CE, 0x113CE }, + { 0x113D0, 0x113D0 }, { 0x113D2, 0x113D2 }, { 0x113E1, 0x113E2 }, + { 0x11438, 0x1143F }, { 0x11442, 0x11444 }, { 0x11446, 0x11446 }, + { 0x1145E, 0x1145E }, { 0x114B3, 0x114B8 }, { 0x114BA, 0x114BA }, + { 0x114BF, 0x114C0 }, { 0x114C2, 0x114C3 }, { 0x115B2, 0x115B5 }, + { 0x115BC, 0x115BD }, { 0x115BF, 0x115C0 }, { 0x115DC, 0x115DD }, + { 0x11633, 0x1163A }, { 0x1163D, 0x1163D }, { 0x1163F, 0x11640 }, + { 0x116AB, 0x116AB }, { 0x116AD, 0x116AD }, { 0x116B0, 0x116B5 }, + { 0x116B7, 0x116B7 }, { 0x1171D, 0x1171D }, { 0x1171F, 0x1171F }, + { 0x11722, 0x11725 }, { 0x11727, 0x1172B }, { 0x1182F, 0x11837 }, + { 0x11839, 0x1183A }, { 0x1193B, 0x1193C }, { 0x1193E, 0x1193E }, + { 0x11943, 0x11943 }, { 0x119D4, 0x119D7 }, { 0x119DA, 0x119DB }, + { 0x119E0, 0x119E0 }, { 0x11A01, 0x11A0A }, { 0x11A33, 0x11A38 }, + { 0x11A3B, 0x11A3E }, { 0x11A47, 0x11A47 }, { 0x11A51, 0x11A56 }, + { 0x11A59, 0x11A5B }, { 0x11A8A, 0x11A96 }, { 0x11A98, 0x11A99 }, + { 0x11B60, 0x11B60 }, { 0x11B62, 0x11B64 }, { 0x11B66, 0x11B66 }, + { 0x11C30, 0x11C36 }, { 0x11C38, 0x11C3D }, { 0x11C3F, 0x11C3F }, + { 0x11C92, 0x11CA7 }, { 0x11CAA, 0x11CB0 }, { 0x11CB2, 0x11CB3 }, + { 0x11CB5, 0x11CB6 }, { 0x11D31, 0x11D36 }, { 0x11D3A, 0x11D3A }, + { 0x11D3C, 0x11D3D }, { 0x11D3F, 0x11D45 }, { 0x11D47, 0x11D47 }, + { 0x11D90, 0x11D91 }, { 0x11D95, 0x11D95 }, { 0x11D97, 0x11D97 }, + { 0x11EF3, 0x11EF4 }, { 0x11F00, 0x11F01 }, { 0x11F36, 0x11F3A }, + { 0x11F40, 0x11F40 }, { 0x11F42, 0x11F42 }, { 0x11F5A, 0x11F5A }, + { 0x13430, 0x13440 }, { 0x13447, 0x13455 }, { 0x1611E, 0x16129 }, + { 0x1612D, 0x1612F }, { 0x16AF0, 0x16AF4 }, { 0x16B30, 0x16B36 }, + { 0x16F4F, 0x16F4F }, { 0x16F8F, 0x16F92 }, { 0x16FE4, 0x16FE4 }, + { 0x1BC9D, 0x1BC9E }, { 0x1BCA0, 0x1BCA3 }, { 0x1CF00, 0x1CF2D }, + { 0x1CF30, 0x1CF46 }, { 0x1D167, 0x1D169 }, { 0x1D173, 0x1D182 }, + { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD }, { 0x1D242, 0x1D244 }, + { 0x1DA00, 0x1DA36 }, { 0x1DA3B, 0x1DA6C }, { 0x1DA75, 0x1DA75 }, + { 0x1DA84, 0x1DA84 }, { 0x1DA9B, 0x1DA9F }, { 0x1DAA1, 0x1DAAF }, + { 0x1E000, 0x1E006 }, { 0x1E008, 0x1E018 }, { 0x1E01B, 0x1E021 }, + { 0x1E023, 0x1E024 }, { 0x1E026, 0x1E02A }, { 0x1E08F, 0x1E08F }, + { 0x1E130, 0x1E136 }, { 0x1E2AE, 0x1E2AE }, { 0x1E2EC, 0x1E2EF }, + { 0x1E4EC, 0x1E4EF }, { 0x1E5EE, 0x1E5EF }, { 0x1E6E3, 0x1E6E3 }, + { 0x1E6E6, 0x1E6E6 }, { 0x1E6EE, 0x1E6EF }, { 0x1E6F5, 0x1E6F5 }, + { 0x1E8D0, 0x1E8D6 }, { 0x1E944, 0x1E94A }, { 0xE0000, 0xE0FFF } + }; + + /* test for 8-bit control characters */ + if (ucs == 0) + return 0; + if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) + return -1; + + /* binary search in table of non-spacing characters */ + if (bisearch(ucs, combining, + sizeof(combining) / sizeof(struct interval) - 1)) + return 0; + + /* sorted list of non-overlapping intervals of wide/fullwidth characters */ + /* Unicode 17.0.0 - East_Asian_Width W and F */ + static const struct interval wide[] = { + { 0x1100, 0x115F }, { 0x231A, 0x231B }, { 0x2329, 0x232A }, + { 0x23E9, 0x23EC }, { 0x23F0, 0x23F0 }, { 0x23F3, 0x23F3 }, + { 0x25FD, 0x25FE }, { 0x2614, 0x2615 }, { 0x2630, 0x2637 }, + { 0x2648, 0x2653 }, { 0x267F, 0x267F }, { 0x268A, 0x268F }, + { 0x2693, 0x2693 }, { 0x26A1, 0x26A1 }, { 0x26AA, 0x26AB }, + { 0x26BD, 0x26BE }, { 0x26C4, 0x26C5 }, { 0x26CE, 0x26CE }, + { 0x26D4, 0x26D4 }, { 0x26EA, 0x26EA }, { 0x26F2, 0x26F3 }, + { 0x26F5, 0x26F5 }, { 0x26FA, 0x26FA }, { 0x26FD, 0x26FD }, + { 0x2705, 0x2705 }, { 0x270A, 0x270B }, { 0x2728, 0x2728 }, + { 0x274C, 0x274C }, { 0x274E, 0x274E }, { 0x2753, 0x2755 }, + { 0x2757, 0x2757 }, { 0x2795, 0x2797 }, { 0x27B0, 0x27B0 }, + { 0x27BF, 0x27BF }, { 0x2B1B, 0x2B1C }, { 0x2B50, 0x2B50 }, + { 0x2B55, 0x2B55 }, { 0x2E80, 0x2E99 }, { 0x2E9B, 0x2EF3 }, + { 0x2F00, 0x2FD5 }, { 0x2FF0, 0x303E }, { 0x3041, 0x3096 }, + { 0x3099, 0x30FF }, { 0x3105, 0x312F }, { 0x3131, 0x318E }, + { 0x3190, 0x31E5 }, { 0x31EF, 0x321E }, { 0x3220, 0x3247 }, + { 0x3250, 0xA48C }, { 0xA490, 0xA4C6 }, { 0xA960, 0xA97C }, + { 0xAC00, 0xD7A3 }, { 0xF900, 0xFAFF }, { 0xFE10, 0xFE19 }, + { 0xFE30, 0xFE52 }, { 0xFE54, 0xFE66 }, { 0xFE68, 0xFE6B }, + { 0xFF01, 0xFF60 }, { 0xFFE0, 0xFFE6 }, + { 0x16FE0, 0x16FE4 }, { 0x16FF0, 0x16FF6 }, + { 0x17000, 0x18CD5 }, { 0x18CFF, 0x18D1E }, { 0x18D80, 0x18DF2 }, + { 0x1AFF0, 0x1AFF3 }, { 0x1AFF5, 0x1AFFB }, + { 0x1AFFD, 0x1AFFE }, { 0x1B000, 0x1B122 }, { 0x1B132, 0x1B132 }, + { 0x1B150, 0x1B152 }, { 0x1B155, 0x1B155 }, { 0x1B164, 0x1B167 }, + { 0x1B170, 0x1B2FB }, { 0x1D300, 0x1D356 }, { 0x1D360, 0x1D376 }, + { 0x1F004, 0x1F004 }, { 0x1F0CF, 0x1F0CF }, { 0x1F18E, 0x1F18E }, + { 0x1F191, 0x1F19A }, { 0x1F200, 0x1F202 }, { 0x1F210, 0x1F23B }, + { 0x1F240, 0x1F248 }, { 0x1F250, 0x1F251 }, { 0x1F260, 0x1F265 }, + { 0x1F300, 0x1F320 }, { 0x1F32D, 0x1F335 }, { 0x1F337, 0x1F37C }, + { 0x1F37E, 0x1F393 }, { 0x1F3A0, 0x1F3CA }, { 0x1F3CF, 0x1F3D3 }, + { 0x1F3E0, 0x1F3F0 }, { 0x1F3F4, 0x1F3F4 }, { 0x1F3F8, 0x1F43E }, + { 0x1F440, 0x1F440 }, { 0x1F442, 0x1F4FC }, { 0x1F4FF, 0x1F53D }, + { 0x1F54B, 0x1F54E }, { 0x1F550, 0x1F567 }, { 0x1F57A, 0x1F57A }, + { 0x1F595, 0x1F596 }, { 0x1F5A4, 0x1F5A4 }, { 0x1F5FB, 0x1F64F }, + { 0x1F680, 0x1F6C5 }, { 0x1F6CC, 0x1F6CC }, { 0x1F6D0, 0x1F6D2 }, + { 0x1F6D5, 0x1F6D8 }, { 0x1F6DC, 0x1F6DF }, { 0x1F6EB, 0x1F6EC }, + { 0x1F6F4, 0x1F6FC }, { 0x1F7E0, 0x1F7EB }, { 0x1F7F0, 0x1F7F0 }, + { 0x1F90C, 0x1F93A }, { 0x1F93C, 0x1F945 }, { 0x1F947, 0x1F9FF }, + { 0x1FA70, 0x1FA7C }, { 0x1FA80, 0x1FA8A }, { 0x1FA8E, 0x1FAC6 }, + { 0x1FAC8, 0x1FAC8 }, { 0x1FACD, 0x1FADC }, { 0x1FADF, 0x1FAEA }, + { 0x1FAEF, 0x1FAF8 }, { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD } + }; + + if (bisearch(ucs, wide, + sizeof(wide) / sizeof(struct interval) - 1)) + return 2; + + return 1; +} + +// End of https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c inherited code + +static int unicode_to_cp437(uint64_t code_point) { + // Braille patterns U+2800-U+28FF: approximate using CP437 block/shade characters. + // Braille dot layout (bit positions): + // bit0 bit3 (row 0) + // bit1 bit4 (row 1) + // bit2 bit5 (row 2) + // bit6 bit7 (row 3) + if (code_point >= 0x2800 && code_point <= 0x28ff) { + uint32_t dots = (uint32_t)(code_point - 0x2800); + + if (dots == 0) return 0x20; + if (dots == 0xff) return 0xdb; + + bool has_top = dots & 0x1b; + bool has_bottom = dots & 0xe4; + bool has_left = dots & 0x47; + bool has_right = dots & 0xb8; + + if (has_top && !has_bottom) return 0xdf; // ▀ + if (has_bottom && !has_top) return 0xdc; // ▄ + if (has_left && !has_right) return 0xdd; // ▌ + if (has_right && !has_left) return 0xde; // ▐ + + // Count set bits for density-based shade + uint32_t n = dots - ((dots >> 1) & 0x55); + n = (n & 0x33) + ((n >> 2) & 0x33); + n = (n + (n >> 4)) & 0x0f; + + if (n <= 2) return 0xb0; // ░ + if (n <= 4) return 0xb1; // ▒ + if (n <= 6) return 0xb2; // ▓ + return 0xdb; // █ + } + + switch (code_point) { + case 0x263a: return 1; + case 0x263b: return 2; + case 0x2665: return 3; + case 0x2666: return 4; + case 0x25c6: return 4; + case 0x2663: return 5; + case 0x2660: return 6; + case 0x2022: return 7; + case 0x25d8: return 8; + case 0x25cb: return 9; + case 0x25d9: return 10; + case 0x2642: return 11; + case 0x2640: return 12; + case 0x266a: return 13; + case 0x266b: return 14; + case 0x263c: return 15; + case 0x00a4: return 15; + case 0x25ba: return 16; + case 0x25b6: return 16; + case 0x25c4: return 17; + case 0x25c0: return 17; + case 0x2195: return 18; + case 0x203c: return 19; + case 0x00b6: return 20; + case 0x00a7: return 21; + case 0x25ac: return 22; + case 0x21a8: return 23; + case 0x2191: return 24; + case 0x2193: return 25; + case 0x2192: return 26; + case 0x2190: return 27; + case 0x221f: return 28; + case 0x2194: return 29; + case 0x25b2: return 30; + case 0x25bc: return 31; + + case 0x00a8: return 0x22; + case 0x00b4: return 0x27; + case 0x00b8: return 0x2c; + case 0x00ad: return 0x2d; + case 0x00c0: return 0x41; + case 0x00c1: return 0x41; + case 0x00c2: return 0x41; + case 0x00c3: return 0x41; + case 0x00a9: return 0x43; + case 0x00d0: return 0x44; + case 0x00c8: return 0x45; + case 0x00ca: return 0x45; + case 0x00cb: return 0x45; + case 0x00cc: return 0x49; + case 0x00cd: return 0x49; + case 0x00ce: return 0x49; + case 0x00cf: return 0x49; + case 0x212a: return 0x4b; + case 0x00d2: return 0x4f; + case 0x00d3: return 0x4f; + case 0x00d4: return 0x4f; + case 0x00d5: return 0x4f; + case 0x00ae: return 0x52; + case 0x00d9: return 0x55; + case 0x00da: return 0x55; + case 0x00db: return 0x55; + case 0x00dd: return 0x59; + case 0x23bd: return 0x5f; + case 0x00e3: return 0x61; + case 0x00f5: return 0x6f; + case 0x00d7: return 0x78; + case 0x00fd: return 0x79; + case 0x00a6: return 0x7c; + + case 0x2302: return 127; + case 0x00c7: return 128; + case 0x00fc: return 129; + case 0x00e9: return 130; + case 0x00e2: return 131; + case 0x00e4: return 132; + case 0x00e0: return 133; + case 0x00e5: return 134; + case 0x00e7: return 135; + case 0x00ea: return 136; + case 0x00eb: return 137; + case 0x00e8: return 138; + case 0x00ef: return 139; + case 0x00ee: return 140; + case 0x00ec: return 141; + case 0x00c4: return 142; + case 0x00c5: return 143; + case 0x212b: return 143; + case 0x00c9: return 144; + case 0x00e6: return 145; + case 0x00c6: return 146; + case 0x00f4: return 147; + case 0x00f6: return 148; + case 0x00f2: return 149; + case 0x00fb: return 150; + case 0x00f9: return 151; + case 0x00ff: return 152; + case 0x00d6: return 153; + case 0x00dc: return 154; + case 0x00a2: return 155; + case 0x00a3: return 156; + case 0x00a5: return 157; + case 0x20a7: return 158; + case 0x0192: return 159; + case 0x00e1: return 160; + case 0x00ed: return 161; + case 0x00f3: return 162; + case 0x00fa: return 163; + case 0x00f1: return 164; + case 0x00d1: return 165; + case 0x00aa: return 166; + case 0x00ba: return 167; + case 0x00bf: return 168; + case 0x2310: return 169; + case 0x00ac: return 170; + case 0x00bd: return 171; + case 0x00bc: return 172; + case 0x00a1: return 173; + case 0x00ab: return 174; + case 0x00bb: return 175; + case 0x2591: return 176; + case 0x2592: return 177; + case 0x2593: return 178; + case 0x2502: return 179; + case 0x2524: return 180; + case 0x2561: return 181; + case 0x2562: return 182; + case 0x2556: return 183; + case 0x2555: return 184; + case 0x2563: return 185; + case 0x2551: return 186; + case 0x2557: return 187; + case 0x255d: return 188; + case 0x255c: return 189; + case 0x255b: return 190; + case 0x2510: return 191; + case 0x2514: return 192; + case 0x2534: return 193; + case 0x252c: return 194; + case 0x251c: return 195; + case 0x2500: return 196; + case 0x253c: return 197; + case 0x255e: return 198; + case 0x255f: return 199; + case 0x255a: return 200; + case 0x2554: return 201; + case 0x2569: return 202; + case 0x2566: return 203; + case 0x2560: return 204; + case 0x2550: return 205; + case 0x256c: return 206; + case 0x2567: return 207; + case 0x2568: return 208; + case 0x2564: return 209; + case 0x2565: return 210; + case 0x2559: return 211; + case 0x2558: return 212; + case 0x2552: return 213; + case 0x2553: return 214; + case 0x256b: return 215; + case 0x256a: return 216; + case 0x2518: return 217; + case 0x250c: return 218; + case 0x2588: return 219; + case 0x2584: return 220; + case 0x258c: return 221; + case 0x2590: return 222; + case 0x2580: return 223; + case 0x03b1: return 224; + case 0x00df: return 225; + case 0x03b2: return 225; + case 0x0393: return 226; + case 0x03c0: return 227; + case 0x03a3: return 228; + case 0x03c3: return 229; + case 0x00b5: return 230; + case 0x03bc: return 230; + case 0x03c4: return 231; + case 0x03a6: return 232; + case 0x00d8: return 232; + case 0x0398: return 233; + case 0x03a9: return 234; + case 0x2126: return 234; + case 0x03b4: return 235; + case 0x00f0: return 235; + case 0x221e: return 236; + case 0x03c6: return 237; + case 0x00f8: return 237; + case 0x03b5: return 238; + case 0x2208: return 238; + case 0x2229: return 239; + case 0x2261: return 240; + case 0x00b1: return 241; + case 0x2265: return 242; + case 0x2264: return 243; + case 0x2320: return 244; + case 0x2321: return 245; + case 0x00f7: return 246; + case 0x2248: return 247; + case 0x00b0: return 248; + case 0x2219: return 249; + case 0x00b7: return 250; + case 0x221a: return 251; + case 0x207f: return 252; + case 0x00b2: return 253; + case 0x25a0: return 254; + case 0xfffd: return 254; + case 0x00a0: return 255; + + // Approximate mappings for Unicode characters without exact CP437 equivalents + + // Rounded/arc box drawing corners + case 0x256d: return 0xda; // ╭ → ┌ + case 0x256e: return 0xbf; // ╮ → ┐ + case 0x256f: return 0xd9; // ╯ → ┘ + case 0x2570: return 0xc0; // ╰ → └ + + // Diagonal box drawing + case 0x2571: return 0x2f; // ╱ → / + case 0x2572: return 0x5c; // ╲ → \ (backslash) + case 0x2573: return 0x58; // ╳ → X + + // Heavy box drawing → single-line equivalents + case 0x2501: return 0xc4; // ━ → ─ + case 0x2503: return 0xb3; // ┃ → │ + case 0x250f: return 0xda; // ┏ → ┌ + case 0x2513: return 0xbf; // ┓ → ┐ + case 0x2517: return 0xc0; // ┗ → └ + case 0x251b: return 0xd9; // ┛ → ┘ + case 0x2523: return 0xc3; // ┣ → ├ + case 0x252b: return 0xb4; // ┫ → ┤ + case 0x2533: return 0xc2; // ┳ → ┬ + case 0x253b: return 0xc1; // ┻ → ┴ + case 0x254b: return 0xc5; // ╋ → ┼ + + // Mixed heavy/light box drawing corners + case 0x250d: return 0xda; // ┍ → ┌ + case 0x250e: return 0xda; // ┎ → ┌ + case 0x2511: return 0xbf; // ┑ → ┐ + case 0x2512: return 0xbf; // ┒ → ┐ + case 0x2515: return 0xc0; // ┕ → └ + case 0x2516: return 0xc0; // ┖ → └ + case 0x2519: return 0xd9; // ┙ → ┘ + case 0x251a: return 0xd9; // ┚ → ┘ + + // Mixed heavy/light box drawing T-pieces + case 0x251d: return 0xc3; // ┝ → ├ + case 0x251e: return 0xc3; // ┞ → ├ + case 0x251f: return 0xc3; // ┟ → ├ + case 0x2520: return 0xc3; // ┠ → ├ + case 0x2521: return 0xc3; // ┡ → ├ + case 0x2522: return 0xc3; // ┢ → ├ + case 0x2525: return 0xb4; // ┥ → ┤ + case 0x2526: return 0xb4; // ┦ → ┤ + case 0x2527: return 0xb4; // ┧ → ┤ + case 0x2528: return 0xb4; // ┨ → ┤ + case 0x2529: return 0xb4; // ┩ → ┤ + case 0x252a: return 0xb4; // ┪ → ┤ + case 0x252d: return 0xc2; // ┭ → ┬ + case 0x252e: return 0xc2; // ┮ → ┬ + case 0x252f: return 0xc2; // ┯ → ┬ + case 0x2530: return 0xc2; // ┰ → ┬ + case 0x2531: return 0xc2; // ┱ → ┬ + case 0x2532: return 0xc2; // ┲ → ┬ + case 0x2535: return 0xc1; // ┵ → ┴ + case 0x2536: return 0xc1; // ┶ → ┴ + case 0x2537: return 0xc1; // ┷ → ┴ + case 0x2538: return 0xc1; // ┸ → ┴ + case 0x2539: return 0xc1; // ┹ → ┴ + case 0x253a: return 0xc1; // ┺ → ┴ + + // Mixed heavy/light box drawing crosses + case 0x253d: return 0xc5; // ┽ → ┼ + case 0x253e: return 0xc5; // ┾ → ┼ + case 0x253f: return 0xc5; // ┿ → ┼ + case 0x2540: return 0xc5; // ╀ → ┼ + case 0x2541: return 0xc5; // ╁ → ┼ + case 0x2542: return 0xc5; // ╂ → ┼ + case 0x2543: return 0xc5; // ╃ → ┼ + case 0x2544: return 0xc5; // ╄ → ┼ + case 0x2545: return 0xc5; // ╅ → ┼ + case 0x2546: return 0xc5; // ╆ → ┼ + case 0x2547: return 0xc5; // ╇ → ┼ + case 0x2548: return 0xc5; // ╈ → ┼ + case 0x2549: return 0xc5; // ╉ → ┼ + case 0x254a: return 0xc5; // ╊ → ┼ + + // Dashed/dotted box drawing → solid equivalents + case 0x2504: return 0xc4; // ┄ → ─ + case 0x2505: return 0xc4; // ┅ → ─ + case 0x2506: return 0xb3; // ┆ → │ + case 0x2507: return 0xb3; // ┇ → │ + case 0x2508: return 0xc4; // ┈ → ─ + case 0x2509: return 0xc4; // ┉ → ─ + case 0x250a: return 0xb3; // ┊ → │ + case 0x250b: return 0xb3; // ┋ → │ + + // Box drawing half-lines and fragments + case 0x2574: return 0xc4; // ╴ → ─ + case 0x2575: return 0xb3; // ╵ → │ + case 0x2576: return 0xc4; // ╶ → ─ + case 0x2577: return 0xb3; // ╷ → │ + case 0x2578: return 0xc4; // ╸ → ─ + case 0x2579: return 0xb3; // ╹ → │ + case 0x257a: return 0xc4; // ╺ → ─ + case 0x257b: return 0xb3; // ╻ → │ + case 0x257c: return 0xc4; // ╼ → ─ + case 0x257d: return 0xb3; // ╽ → │ + case 0x257e: return 0xc4; // ╾ → ─ + case 0x257f: return 0xb3; // ╿ → │ + + // Triangle variants → filled equivalents + case 0x25b3: return 30; // △ → ▲ + case 0x25b5: return 30; // ▵ → ▲ + case 0x25b7: return 16; // ▷ → ► + case 0x25b9: return 16; // ▹ → ► + case 0x25bd: return 31; // ▽ → ▼ + case 0x25bf: return 31; // ▿ → ▼ + case 0x25c1: return 17; // ◁ → ◄ + case 0x25c3: return 17; // ◃ → ◄ + + // Fractional block elements → closest CP437 block + case 0x2581: return 0xdc; // ▁ (lower 1/8) → ▄ + case 0x2582: return 0xdc; // ▂ (lower 1/4) → ▄ + case 0x2583: return 0xdc; // ▃ (lower 3/8) → ▄ + case 0x2585: return 0xdc; // ▅ (lower 5/8) → ▄ + case 0x2586: return 0xdb; // ▆ (lower 3/4) → █ + case 0x2587: return 0xdb; // ▇ (lower 7/8) → █ + case 0x2589: return 0xdb; // ▉ (left 7/8) → █ + case 0x258a: return 0xdb; // ▊ (left 3/4) → █ + case 0x258b: return 0xdd; // ▋ (left 5/8) → ▌ + case 0x258d: return 0xdd; // ▍ (left 3/8) → ▌ + case 0x258e: return 0xdd; // ▎ (left 1/4) → ▌ + case 0x258f: return 0xdd; // ▏ (left 1/8) → ▌ + case 0x2594: return 0xdf; // ▔ (upper 1/8) → ▀ + case 0x2595: return 0xde; // ▕ (right 1/8) → ▐ + + // Quadrant block elements + case 0x2596: return 0xdc; // ▖ → ▄ + case 0x2597: return 0xdc; // ▗ → ▄ + case 0x2598: return 0xdf; // ▘ → ▀ + case 0x2599: return 0xdb; // ▙ → █ + case 0x259a: return 0xb1; // ▚ → ▒ + case 0x259b: return 0xdb; // ▛ → █ + case 0x259c: return 0xdb; // ▜ → █ + case 0x259d: return 0xdf; // ▝ → ▀ + case 0x259e: return 0xb1; // ▞ → ▒ + case 0x259f: return 0xdb; // ▟ → █ + + // Circles and bullets + case 0x25cf: return 0x07; // ● → • + case 0x25c9: return 0x0a; // ◉ → ◙ + case 0x25ef: return 0x09; // ◯ → ○ + case 0x25e6: return 0x09; // ◦ → ○ + case 0x25aa: return 0xfe; // ▪ → ■ + case 0x25fc: return 0xfe; // ◼ → ■ + + // Typographic punctuation + case 0x2013: return 0x2d; // – (en dash) → - + case 0x2014: return 0x2d; // — (em dash) → - + case 0x2018: return 0x27; // ' (left single quote) → ' + case 0x2019: return 0x27; // ' (right single quote) → ' + case 0x201c: return 0x22; // " (left double quote) → " + case 0x201d: return 0x22; // " (right double quote) → " + case 0x2026: return 0xfa; // … (ellipsis) → · + case 0x2212: return 0x2d; // − (minus sign) → - + + // Check marks + case 0x2713: return 0xfb; // ✓ → √ + case 0x2714: return 0xfb; // ✔ → √ + + // Double arrows → single arrow equivalents + case 0x21d0: return 27; // ⇐ → ← + case 0x21d1: return 24; // ⇑ → ↑ + case 0x21d2: return 26; // ⇒ → → + case 0x21d3: return 25; // ⇓ → ↓ + case 0x21d4: return 29; // ⇔ → ↔ + case 0x21d5: return 18; // ⇕ → ↕ + + // Summation sign + case 0x2211: return 0xe4; // ∑ → Σ + + // Horizontal line extension + case 0x23af: return 0xc4; // ⎯ → ─ + + // Media transport symbols + case 0x23f4: return 17; // ⏴ → ◄ + case 0x23f5: return 16; // ⏵ → ► + case 0x23f6: return 30; // ⏶ → ▲ + case 0x23f7: return 31; // ⏷ → ▼ + case 0x23f8: return 0xba; // ⏸ → ║ + case 0x23f9: return 0xfe; // ⏹ → ■ + case 0x23fa: return 0x07; // ⏺ → • + + // Square bracket pieces + case 0x23a1: return 0xda; // ⎡ → ┌ + case 0x23a2: return 0xb3; // ⎢ → │ + case 0x23a3: return 0xc0; // ⎣ → └ + case 0x23a4: return 0xbf; // ⎤ → ┐ + case 0x23a5: return 0xb3; // ⎥ → │ + case 0x23a6: return 0xd9; // ⎦ → ┘ + + // Curly bracket pieces + case 0x23a7: return 0xda; // ⎧ → ┌ + case 0x23a8: return 0xc3; // ⎨ → ├ + case 0x23a9: return 0xc0; // ⎩ → └ + case 0x23aa: return 0xb3; // ⎪ → │ + case 0x23ab: return 0xbf; // ⎫ → ┐ + case 0x23ac: return 0xb4; // ⎬ → ┤ + case 0x23ad: return 0xd9; // ⎭ → ┘ + case 0x23ae: return 0xb3; // ⎮ → │ + + // Vertical box lines + case 0x23b8: return 0xb3; // ⎸ → │ + case 0x23b9: return 0xb3; // ⎹ → │ + + // Horizontal scan lines (0x23bd already mapped above) + case 0x23ba: return 0xc4; // ⎺ → ─ + case 0x23bb: return 0xc4; // ⎻ → ─ + case 0x23bc: return 0xc4; // ⎼ → ─ + + // Dentistry/angle symbols + case 0x23be: return 0xb3; // ⎾ → │ + case 0x23bf: return 0xc0; // ⎿ → └ + + // Corner brackets + case 0x231c: return 0xda; // ⌜ → ┌ + case 0x231d: return 0xbf; // ⌝ → ┐ + case 0x231e: return 0xc0; // ⌞ → └ + case 0x231f: return 0xd9; // ⌟ → ┘ + } + + return -1; +} + +static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) { + if (ctx->discard_next || (c == 0x18 || c == 0x1a)) { + ctx->discard_next = false; + ctx->escape = false; + ctx->control_sequence = false; + ctx->unicode_remaining = 0; + ctx->osc = false; + ctx->osc_escape = false; + ctx->g_select = 0; + ctx->last_was_graphic = false; + return; + } + + if (ctx->unicode_remaining != 0) { + if ((c & 0xc0) != 0x80) { + ctx->unicode_remaining = 0; + ctx->raw_putchar(ctx, 0xfe); + goto unicode_error; + } + + ctx->unicode_remaining--; + ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining); + + // Reject overlong encodings and out-of-range codepoints early + // by validating the first continuation byte against the lead byte. + // 3-byte lead E0: first continuation must be >= 0xA0 (code_point >= 0x800) + // 4-byte lead F0: first continuation must be >= 0x90 (code_point >= 0x10000) + // 4-byte lead F4: first continuation must be <= 0x8F (code_point <= 0x10FFFF) + if (ctx->unicode_remaining == 1 && ctx->code_point < 0x800) { + ctx->unicode_remaining = 0; + goto unicode_error; + } + if (ctx->unicode_remaining == 2 && ctx->code_point < 0x10000) { + ctx->unicode_remaining = 0; + goto unicode_error; + } + if (ctx->unicode_remaining == 2 && ctx->code_point > 0x10ffff) { + ctx->unicode_remaining = 0; + goto unicode_error; + } + + if (ctx->unicode_remaining != 0) { + return; + } + + if (ctx->code_point >= 0xd800 && ctx->code_point <= 0xdfff) { + goto unicode_error; + } + + int cc = unicode_to_cp437(ctx->code_point); + + if (cc == -1) { + int replacement_width = mk_wcwidth(ctx->code_point); + if (replacement_width > 0) { + ctx->last_printed_char = 0xfe; + ctx->last_was_graphic = true; + ctx->raw_putchar(ctx, 0xfe); + } + for (int i = 1; i < replacement_width; i++) { + ctx->raw_putchar(ctx, ' '); + } + } else { + ctx->last_printed_char = cc; + ctx->last_was_graphic = true; + ctx->raw_putchar(ctx, cc); + } + return; + } + +unicode_error: + if (c >= 0xc2 && c <= 0xf4) { + ctx->g_select = 0; + if (c >= 0xc2 && c <= 0xdf) { + ctx->unicode_remaining = 1; + ctx->code_point = (uint64_t)(c & 0x1f) << 6; + } else if (c >= 0xe0 && c <= 0xef) { + ctx->unicode_remaining = 2; + ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2); + } else if (c >= 0xf0 && c <= 0xf4) { + ctx->unicode_remaining = 3; + ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3); + } + return; + } + + if (ctx->escape == true) { + escape_parse(ctx, c); + return; + } + + if (ctx->g_select) { + if (c <= 0x1f || c == 0x7f) { + ctx->g_select = 0; + } else { + ctx->g_select--; + switch (c) { + case 'B': + ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break; + case '0': + ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break; + } + ctx->g_select = 0; + return; + } + } + + if ((c <= 0x1f && c != 0x1b) || c == 0x7f) { + ctx->last_was_graphic = false; + } + + size_t x, y; + ctx->get_cursor_pos(ctx, &x, &y); + + switch (c) { + case 0x00: + case 0x7f: + return; + case 0x1b: + ctx->escape_offset = 0; + ctx->escape = true; + return; + case '\t': { + size_t next_tab = (x / ctx->tab_size + 1) * ctx->tab_size; + if (next_tab >= ctx->cols) { + ctx->set_cursor_pos(ctx, ctx->cols - 1, y); + return; + } + ctx->set_cursor_pos(ctx, next_tab, y); + return; + } + case 0x0b: + case 0x0c: + case '\n': + if (y == ctx->scroll_bottom_margin - 1) { + ctx->scroll(ctx); + ctx->set_cursor_pos(ctx, x, y); + } else { + ctx->set_cursor_pos(ctx, x, y + 1); + } + return; + case '\b': + if (x > 0) { + ctx->set_cursor_pos(ctx, x - 1, y); + } + return; + case '\r': + ctx->set_cursor_pos(ctx, 0, y); + return; + case '\a': + // The bell is handled by the kernel + if (ctx->callback != NULL) { + ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0); + } + return; + case 14: + // Move to G1 set + ctx->current_charset = 1; + return; + case 15: + // Move to G0 set + ctx->current_charset = 0; + return; + } + + if (ctx->insert_mode == true) { + for (size_t i = ctx->cols - 1; i > x; i--) { + ctx->move_character(ctx, i, y, i - 1, y); + } + } + + // Translate character set + switch (ctx->charsets[ctx->current_charset]) { + case CHARSET_DEFAULT: + break; + case CHARSET_DEC_SPECIAL: + if (dec_special_print(ctx, c)) { + return; + } + break; + } + + if (c >= 0x20 && c <= 0x7e) { + ctx->last_printed_char = c; + ctx->last_was_graphic = true; + ctx->raw_putchar(ctx, c); + } else if (c >= 0x80) { + ctx->last_printed_char = 0xfe; + ctx->last_was_graphic = true; + ctx->raw_putchar(ctx, 0xfe); + } +} + +void flanterm_flush(struct flanterm_context *ctx) { + ctx->double_buffer_flush(ctx); +} + +void flanterm_full_refresh(struct flanterm_context *ctx) { + ctx->full_refresh(ctx); +} + +void flanterm_deinit(struct flanterm_context *ctx, void (*_free)(void *, size_t)) { + ctx->deinit(ctx, _free); +} + +void flanterm_get_dimensions(struct flanterm_context *ctx, size_t *cols, size_t *rows) { + *cols = ctx->cols; + *rows = ctx->rows; +} + +void flanterm_set_autoflush(struct flanterm_context *ctx, bool state) { + ctx->autoflush = state; +} + +void flanterm_set_callback(struct flanterm_context *ctx, void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t)) { + ctx->callback = callback; +} + diff --git a/src/io/term/flanterm.h b/src/io/term/flanterm.h new file mode 100644 index 0000000..6c49b4c --- /dev/null +++ b/src/io/term/flanterm.h @@ -0,0 +1,72 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/* Copyright (C) 2022-2026 Mintsuki and contributors. + * + * 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 HOLDER 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. + */ + +#ifndef FLANTERM_H +#define FLANTERM_H 1 + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define FLANTERM_CB_DEC 10 +#define FLANTERM_CB_BELL 20 +#define FLANTERM_CB_PRIVATE_ID 30 +#define FLANTERM_CB_STATUS_REPORT 40 +#define FLANTERM_CB_POS_REPORT 50 +#define FLANTERM_CB_KBD_LEDS 60 +#define FLANTERM_CB_MODE 70 +#define FLANTERM_CB_LINUX 80 +#define FLANTERM_CB_OSC 90 + +#ifdef FLANTERM_IN_FLANTERM + +#include "flanterm_private.h" + +#else + +struct flanterm_context; + +#endif + +void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count); +void flanterm_flush(struct flanterm_context *ctx); +void flanterm_full_refresh(struct flanterm_context *ctx); +void flanterm_deinit(struct flanterm_context *ctx, void (*_free)(void *ptr, size_t size)); + +void flanterm_get_dimensions(struct flanterm_context *ctx, size_t *cols, size_t *rows); +void flanterm_set_autoflush(struct flanterm_context *ctx, bool state); +void flanterm_set_callback(struct flanterm_context *ctx, void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/io/term/flanterm_backends/fb.c b/src/io/term/flanterm_backends/fb.c new file mode 100644 index 0000000..5f05b82 --- /dev/null +++ b/src/io/term/flanterm_backends/fb.c @@ -0,0 +1,1460 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/* Copyright (C) 2022-2026 Mintsuki and contributors. + * + * 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 HOLDER 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 + +#ifdef __cplusplus +#error "Please do not compile Flanterm as C++ code! Flanterm should be compiled as C99 or newer." +#endif + +#ifndef __STDC_VERSION__ +#error "Flanterm must be compiled as C99 or newer." +#endif + +#if defined(_MSC_VER) +#define ALWAYS_INLINE __forceinline +#elif defined(__GNUC__) || defined(__clang__) +#define ALWAYS_INLINE __attribute__((always_inline)) inline +#else +#define ALWAYS_INLINE inline +#endif + +#include +#include +#include + +#ifndef FLANTERM_IN_FLANTERM +#define FLANTERM_IN_FLANTERM +#endif + +#include "../flanterm.h" +#include "fb.h" + +void *memset(void *, int, size_t); +void *memcpy(void *, const void *, size_t); + +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + +#ifndef FLANTERM_FB_BUMP_ALLOC_POOL_SIZE +#define FLANTERM_FB_BUMP_ALLOC_POOL_SIZE 873000 + +#define FLANTERM_FB_WIDTH_LIMIT 1920 +#define FLANTERM_FB_HEIGHT_LIMIT 1200 +#endif + +static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE]; +static size_t bump_alloc_ptr = 0; +static bool bump_alloc_base_offset_added = false; + +static void *bump_alloc(size_t s) { + if (!bump_alloc_base_offset_added) { + if ((uintptr_t)bump_alloc_pool & 0xf) { + bump_alloc_ptr += 0x10 - ((uintptr_t)bump_alloc_pool & 0xf); + } + bump_alloc_base_offset_added = true; + } + + if ((s & 0xf) != 0) { + s += 0x10; + s &= ~(size_t)0xf; + } + + size_t next_ptr = bump_alloc_ptr + s; + if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) { + return NULL; + } + void *ret = &bump_alloc_pool[bump_alloc_ptr]; + bump_alloc_ptr = next_ptr; + return ret; +} + +static bool bump_allocated_instance = false; + +#endif + +// Builtin font originally taken from: +// https://github.com/viler-int10h/vga-text-mode-fonts/raw/master/FONTS/PC-OTHER/TOSH-SAT.F16 +static const uint8_t builtin_font[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x81, 0x81, 0xa5, 0xa5, 0x81, + 0x81, 0xa5, 0x99, 0x81, 0x42, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x7e, 0xff, + 0xff, 0xdb, 0xdb, 0xff, 0xff, 0xdb, 0xe7, 0xff, 0x7e, 0x3c, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x7c, 0x38, 0x38, 0x10, + 0x10, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, + 0x7c, 0x7c, 0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, + 0x3c, 0x3c, 0xdb, 0xff, 0xff, 0xdb, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0xff, 0x66, 0x18, 0x18, + 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78, + 0x78, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0x84, 0x84, 0xcc, 0x78, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, + 0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x1e, + 0x0e, 0x1e, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0xfc, 0x30, 0x30, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x18, 0x1c, 0x1e, 0x16, 0x12, + 0x10, 0x10, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x38, 0x2c, + 0x26, 0x32, 0x3a, 0x2e, 0x26, 0x22, 0x62, 0xe2, 0xc6, 0x0e, 0x0c, 0x00, + 0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf8, 0xfe, + 0xf8, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x06, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x30, 0x78, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x78, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xcc, 0xcc, 0x00, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xdb, + 0xdb, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, + 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78, + 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x78, 0x30, 0xfc, 0x00, 0x00, + 0x00, 0x00, 0x30, 0x78, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0xfc, 0x78, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x18, 0x0c, 0xfe, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0xfe, 0x60, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, + 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x24, 0x66, 0xff, 0xff, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, + 0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x30, 0x78, 0x78, 0x78, 0x78, 0x30, 0x30, 0x30, 0x00, 0x30, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, + 0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, + 0x00, 0x18, 0x18, 0x7c, 0xc6, 0xc0, 0xc0, 0x7c, 0x06, 0x06, 0xc6, 0x7c, + 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x0c, 0x0c, 0x18, 0x38, + 0x30, 0x60, 0x60, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, + 0x6c, 0x38, 0x30, 0x76, 0xde, 0xcc, 0xcc, 0xde, 0x76, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x60, 0x60, 0x60, + 0x60, 0x60, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x38, 0xfe, 0x38, 0x6c, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, + 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, + 0x0c, 0x0c, 0x18, 0x38, 0x30, 0x60, 0x60, 0xc0, 0xc0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, + 0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0x06, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, + 0xfe, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, + 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3c, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, + 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c, + 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, + 0x18, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, + 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x0c, + 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, + 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, + 0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x06, 0x0c, 0x18, 0x30, 0x30, 0x00, 0x30, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xde, + 0xde, 0xde, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, + 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc, + 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, + 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, + 0xc0, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xc6, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6, + 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, + 0xee, 0xfe, 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xc6, 0xc6, 0xe6, 0xe6, 0xf6, 0xde, 0xce, 0xce, 0xc6, 0xc6, + 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6, + 0xc6, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xf6, 0xda, + 0x6c, 0x06, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc, + 0xd8, 0xcc, 0xcc, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, + 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, + 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x38, + 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, + 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0x06, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc0, 0xc0, + 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x60, 0x60, 0x60, 0x60, 0x60, + 0x60, 0x60, 0x60, 0x60, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, + 0x60, 0x60, 0x30, 0x38, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x18, 0x18, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x06, 0x06, + 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, + 0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xe6, 0xdc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x76, 0xce, 0xc6, + 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x36, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xce, 0xc6, + 0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xc0, 0xc0, + 0xc0, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x1e, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xc0, 0xc0, + 0xc0, 0xc6, 0xcc, 0xd8, 0xf0, 0xf0, 0xd8, 0xcc, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0xfe, 0xd6, + 0xd6, 0xd6, 0xd6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc6, + 0xc6, 0xc6, 0xe6, 0xdc, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x76, 0xce, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0x06, 0x06, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, + 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, + 0x70, 0x1c, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, + 0x30, 0xfe, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xc6, 0xc6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x6c, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6, + 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x30, 0x30, 0x30, 0x30, 0xe0, 0x30, 0x30, 0x30, 0x30, + 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x30, + 0x30, 0x30, 0x30, 0x1c, 0x30, 0x30, 0x30, 0x30, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x6c, + 0x6c, 0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x18, 0xcc, 0x78, 0x00, + 0x00, 0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xc6, + 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, + 0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, + 0x7e, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0x06, 0x06, + 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, + 0x00, 0x7c, 0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc6, + 0x7c, 0x18, 0x0c, 0x38, 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, + 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, + 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, 0x7e, 0x00, 0x00, 0x00, + 0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xc6, 0xfe, 0xc0, 0xc0, 0xc0, + 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, + 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, + 0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x3c, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, + 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00, + 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x18, 0x30, 0x60, 0x00, 0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, + 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0x36, 0x36, + 0x76, 0xde, 0xd8, 0xd8, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x3c, + 0x6c, 0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, + 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x38, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x6c, + 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0xc6, 0x7c, 0x00, + 0x6c, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x6c, 0x6c, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, + 0x30, 0x78, 0xcc, 0xc0, 0xc0, 0xcc, 0x78, 0x30, 0x30, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x6c, 0x60, 0x60, 0x60, 0xf8, 0x60, 0x60, 0x60, 0xe6, + 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0xfc, + 0x30, 0xfc, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc, + 0xcc, 0xf8, 0xc4, 0xcc, 0xde, 0xcc, 0xcc, 0xcc, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, + 0x18, 0xd8, 0x70, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0x06, 0x06, + 0x7e, 0xc6, 0xc6, 0xc6, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, + 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, + 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0xc6, 0xc6, 0xc6, + 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, + 0x00, 0xdc, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x76, 0xdc, 0x00, 0xc6, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, + 0xc6, 0x00, 0x00, 0x00, 0x00, 0x78, 0xd8, 0xd8, 0x6c, 0x00, 0xfc, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c, + 0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xc6, + 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xc0, 0xc2, 0xc6, 0xcc, 0xd8, 0x30, 0x60, 0xdc, 0x86, 0x0c, + 0x18, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc2, 0xc6, 0xcc, 0xd8, 0x30, + 0x66, 0xce, 0x9e, 0x3e, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, + 0x00, 0x30, 0x30, 0x30, 0x78, 0x78, 0x78, 0x78, 0x30, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36, + 0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x88, 0x22, 0x88, + 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, + 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, + 0x55, 0xaa, 0x55, 0xaa, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, + 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, + 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18, + 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, + 0x36, 0xf6, 0xf6, 0x06, 0x06, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x06, + 0x06, 0xf6, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0xf6, 0xf6, 0x06, 0x06, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, + 0x18, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, + 0x37, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x37, 0x37, 0x30, 0x30, 0x3f, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x3f, 0x30, 0x30, 0x37, 0x37, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0xf7, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xf7, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x37, 0x30, 0x30, 0x37, 0x37, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, + 0x36, 0xf7, 0xf7, 0x00, 0x00, 0xf7, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f, + 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x1f, 0x1f, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, + 0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x36, 0x36, 0x36, 0xff, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, + 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0xff, 0xff, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, + 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x76, 0xd6, 0xdc, 0xc8, 0xc8, 0xdc, 0xd6, 0x76, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, + 0xd8, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x7e, 0xfe, 0x24, 0x24, 0x24, 0x24, 0x66, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0xfe, 0xc2, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc2, 0xfe, + 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xc8, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x76, 0x6c, 0x60, 0xc0, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0xfc, 0x98, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x30, 0x30, 0x78, 0xcc, 0xcc, + 0xcc, 0x78, 0x30, 0x30, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, + 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c, + 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0x60, 0x30, 0x78, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x76, 0xbb, 0x99, 0x99, 0xdd, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x02, 0x06, 0x3c, 0x6c, 0xce, 0xd6, 0xd6, 0xe6, 0x6c, 0x78, + 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x30, 0x60, 0xc0, 0xc0, 0xfe, + 0xc0, 0xc0, 0x60, 0x30, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, + 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc, + 0x30, 0x30, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00, 0xfc, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x00, + 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x36, 0x36, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0xfc, 0x00, 0x30, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, + 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0xcc, + 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0x6c, 0x3c, 0x1c, 0x0c, 0x00, 0x00, + 0x00, 0xd8, 0xec, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x0c, 0x18, 0x30, 0x60, 0x7c, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00 +}; + +static ALWAYS_INLINE uint32_t convert_colour(struct flanterm_context *_ctx, uint32_t colour) { + struct flanterm_fb_context *ctx = (void *)_ctx; + uint32_t r = (colour >> 16) & 0xff; + uint32_t g = (colour >> 8) & 0xff; + uint32_t b = colour & 0xff; + uint32_t ret = (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift); + if (ctx->red_mask_size > 8) { + ret |= (r >> (16 - ctx->red_mask_size)) << (ctx->red_mask_shift + 8); + } + if (ctx->green_mask_size > 8) { + ret |= (g >> (16 - ctx->green_mask_size)) << (ctx->green_mask_shift + 8); + } + if (ctx->blue_mask_size > 8) { + ret |= (b >> (16 - ctx->blue_mask_size)) << (ctx->blue_mask_shift + 8); + } + return ret; +} + +static void flanterm_fb_save_state(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->saved_state_text_fg = ctx->text_fg; + ctx->saved_state_text_bg = ctx->text_bg; + ctx->saved_state_cursor_x = ctx->cursor_x; + ctx->saved_state_cursor_y = ctx->cursor_y; +} + +static void flanterm_fb_restore_state(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->text_fg = ctx->saved_state_text_fg; + ctx->text_bg = ctx->saved_state_text_bg; + ctx->cursor_x = ctx->saved_state_cursor_x; + ctx->cursor_y = ctx->saved_state_cursor_y; +} + +static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + uint32_t tmp = ctx->text_bg; + ctx->text_bg = ctx->text_fg; + ctx->text_fg = tmp; + if (ctx->text_fg == 0xffffffff) { + ctx->text_fg = ctx->default_bg; + } + if (ctx->text_bg == ctx->default_bg) { + ctx->text_bg = 0xffffffff; + } +} + +static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { + return; + } + + x = ctx->offset_x + x * ctx->glyph_width; + y = ctx->offset_y + y * ctx->glyph_height; + + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; + + volatile uint32_t *dest; + int outer_stride, inner_stride; + + switch (ctx->rotation) { + default: + case FLANTERM_FB_ROTATE_0: + dest = ctx->framebuffer + x + y * (ctx->pitch / 4); + outer_stride = ctx->pitch / 4; + inner_stride = 1; + break; + case FLANTERM_FB_ROTATE_90: + dest = ctx->framebuffer + (ctx->height - 1 - y) + x * (ctx->pitch / 4); + outer_stride = -1; + inner_stride = ctx->pitch / 4; + break; + case FLANTERM_FB_ROTATE_180: + dest = ctx->framebuffer + (ctx->width - 1 - x) + (ctx->height - 1 - y) * (ctx->pitch / 4); + outer_stride = -(ctx->pitch / 4); + inner_stride = -1; + break; + case FLANTERM_FB_ROTATE_270: + dest = ctx->framebuffer + y + (ctx->width - 1 - x) * (ctx->pitch / 4); + outer_stride = 1; + inner_stride = -(ctx->pitch / 4); + break; + } + + // naming: fx,fy for font coordinates, gx,gy for glyph coordinates + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { + uint8_t fy = gy / ctx->font_scale_y; + volatile uint32_t *fb_line = dest; + uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width; + bool *glyph_pointer = glyph + (fy * ctx->font_width); + for (size_t fx = 0; fx < ctx->font_width; fx++) { + for (size_t i = 0; i < ctx->font_scale_x; i++) { + size_t gx = ctx->font_scale_x * fx + i; + uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg; + uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg; + *fb_line = *glyph_pointer ? fg : bg; + fb_line += inner_stride; + } + glyph_pointer++; + } + dest += outer_stride; + } +} + +static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { + return; + } + + uint32_t default_bg = ctx->default_bg; + + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; + uint32_t fg = c->fg == 0xffffffff ? ctx->default_fg : c->fg; + + x = ctx->offset_x + x * ctx->glyph_width; + y = ctx->offset_y + y * ctx->glyph_height; + + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; + + volatile uint32_t *dest; + int outer_stride, inner_stride; + + switch (ctx->rotation) { + default: + case FLANTERM_FB_ROTATE_0: + dest = ctx->framebuffer + x + y * (ctx->pitch / 4); + outer_stride = ctx->pitch / 4; + inner_stride = 1; + break; + case FLANTERM_FB_ROTATE_90: + dest = ctx->framebuffer + (ctx->height - 1 - y) + x * (ctx->pitch / 4); + outer_stride = -1; + inner_stride = ctx->pitch / 4; + break; + case FLANTERM_FB_ROTATE_180: + dest = ctx->framebuffer + (ctx->width - 1 - x) + (ctx->height - 1 - y) * (ctx->pitch / 4); + outer_stride = -(ctx->pitch / 4); + inner_stride = -1; + break; + case FLANTERM_FB_ROTATE_270: + dest = ctx->framebuffer + y + (ctx->width - 1 - x) * (ctx->pitch / 4); + outer_stride = 1; + inner_stride = -(ctx->pitch / 4); + break; + } + + // naming: fx,fy for font coordinates, gx,gy for glyph coordinates + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { + uint8_t fy = gy / ctx->font_scale_y; + volatile uint32_t *fb_line = dest; + bool *glyph_pointer = glyph + (fy * ctx->font_width); + for (size_t fx = 0; fx < ctx->font_width; fx++) { + for (size_t i = 0; i < ctx->font_scale_x; i++) { + *fb_line = *glyph_pointer ? fg : bg; + fb_line += inner_stride; + } + glyph_pointer++; + } + dest += outer_stride; + } +} + +static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { + return; + } + + x = ctx->offset_x + x * ctx->glyph_width; + y = ctx->offset_y + y * ctx->glyph_height; + + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; + + volatile uint32_t *dest; + int outer_stride, inner_stride; + + switch (ctx->rotation) { + default: + case FLANTERM_FB_ROTATE_0: + dest = ctx->framebuffer + x + y * (ctx->pitch / 4); + outer_stride = ctx->pitch / 4; + inner_stride = 1; + break; + case FLANTERM_FB_ROTATE_90: + dest = ctx->framebuffer + (ctx->height - 1 - y) + x * (ctx->pitch / 4); + outer_stride = -1; + inner_stride = ctx->pitch / 4; + break; + case FLANTERM_FB_ROTATE_180: + dest = ctx->framebuffer + (ctx->width - 1 - x) + (ctx->height - 1 - y) * (ctx->pitch / 4); + outer_stride = -(ctx->pitch / 4); + inner_stride = -1; + break; + case FLANTERM_FB_ROTATE_270: + dest = ctx->framebuffer + y + (ctx->width - 1 - x) * (ctx->pitch / 4); + outer_stride = 1; + inner_stride = -(ctx->pitch / 4); + break; + } + + // naming: fx,fy for font coordinates, gx,gy for glyph coordinates + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { + volatile uint32_t *fb_line = dest; + uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width; + bool *glyph_pointer = glyph + (gy * ctx->font_width); + for (size_t fx = 0; fx < ctx->font_width; fx++) { + uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg; + uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg; + *fb_line = *(glyph_pointer++) ? fg : bg; + fb_line += inner_stride; + } + dest += outer_stride; + } +} + +static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { + + if (_ctx == NULL) + { + panic(NULL, "plot_char_unscaled_uncanvas: _ctx is NULL"); + } + + if (c == NULL) + { + panic(NULL, "plot_char_unscaled_uncanvas: c is NULL"); + } + + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { + return; + } + + uint32_t default_bg = ctx->default_bg; + + uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg; + uint32_t fg = c->fg == 0xffffffff ? ctx->default_fg : c->fg; + + x = ctx->offset_x + x * ctx->glyph_width; + y = ctx->offset_y + y * ctx->glyph_height; + + bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width]; + + volatile uint32_t *dest; + int outer_stride, inner_stride; + + switch (ctx->rotation) { + default: + case FLANTERM_FB_ROTATE_0: + dest = ctx->framebuffer + x + y * (ctx->pitch / 4); + outer_stride = ctx->pitch / 4; + inner_stride = 1; + break; + case FLANTERM_FB_ROTATE_90: + dest = ctx->framebuffer + (ctx->height - 1 - y) + x * (ctx->pitch / 4); + outer_stride = -1; + inner_stride = ctx->pitch / 4; + break; + case FLANTERM_FB_ROTATE_180: + dest = ctx->framebuffer + (ctx->width - 1 - x) + (ctx->height - 1 - y) * (ctx->pitch / 4); + outer_stride = -(ctx->pitch / 4); + inner_stride = -1; + break; + case FLANTERM_FB_ROTATE_270: + dest = ctx->framebuffer + y + (ctx->width - 1 - x) * (ctx->pitch / 4); + outer_stride = 1; + inner_stride = -(ctx->pitch / 4); + break; + } + + // naming: fx,fy for font coordinates, gx,gy for glyph coordinates + for (size_t gy = 0; gy < ctx->glyph_height; gy++) { + volatile uint32_t *fb_line = dest; + bool *glyph_pointer = glyph + (gy * ctx->font_width); + for (size_t fx = 0; fx < ctx->font_width; fx++) { + *fb_line = *(glyph_pointer++) ? fg : bg; + fb_line += inner_stride; + } + dest += outer_stride; + } +} + +static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) { + return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg); +} + +static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols || y >= _ctx->rows) { + return; + } + + size_t i = y * _ctx->cols + x; + + struct flanterm_fb_queue_item *q = ctx->map[i]; + + if (q == NULL) { + if (compare_char(&ctx->grid[i], c)) { + return; + } + if (ctx->queue_i == _ctx->rows * _ctx->cols) { + return; + } + q = &ctx->queue[ctx->queue_i++]; + q->x = x; + q->y = y; + ctx->map[i] = q; + } + + q->c = *c; +} + +static void flanterm_fb_revscroll(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + size_t start = _ctx->scroll_top_margin * _ctx->cols; + size_t end = (_ctx->scroll_bottom_margin - 1) * _ctx->cols; + for (size_t i = end; i > start; ) { + i--; + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; + if (q != NULL) { + c = &q->c; + } else { + c = &ctx->grid[i]; + } + push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols); + } + + // Clear the first line of the screen. + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->cols; i++) { + push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin); + } +} + +static void flanterm_fb_scroll(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols; + i < _ctx->scroll_bottom_margin * _ctx->cols; i++) { + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; + if (q != NULL) { + c = &q->c; + } else { + c = &ctx->grid[i]; + } + push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols); + } + + // Clear the last line of the screen. + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->cols; i++) { + push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1); + } +} + +static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + struct flanterm_fb_char empty; + empty.c = ' '; + empty.fg = ctx->text_fg; + empty.bg = ctx->text_bg; + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { + push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols); + } + + if (move) { + ctx->cursor_x = 0; + ctx->cursor_y = 0; + } +} + +static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (x >= _ctx->cols) { + if (x > SIZE_MAX / 2) { + x = 0; + } else { + x = _ctx->cols - 1; + } + } + if (y >= _ctx->rows) { + if (y > SIZE_MAX / 2) { + y = 0; + } else { + y = _ctx->rows - 1; + } + } + ctx->cursor_x = x; + ctx->cursor_y = y; +} + +static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x; + *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y; +} + +static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (old_x >= _ctx->cols || old_y >= _ctx->rows + || new_x >= _ctx->cols || new_y >= _ctx->rows) { + return; + } + + size_t i = old_x + old_y * _ctx->cols; + + struct flanterm_fb_char *c; + struct flanterm_fb_queue_item *q = ctx->map[i]; + if (q != NULL) { + c = &q->c; + } else { + c = &ctx->grid[i]; + } + + push_to_queue(_ctx, c, new_x, new_y); +} + +static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->ansi_colours[fg]; +} + +static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->ansi_colours[bg]; +} + +static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->ansi_bright_colours[fg]; +} + +static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->ansi_bright_colours[bg]; +} + +static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = convert_colour(_ctx, fg); +} + +static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = convert_colour(_ctx, bg); +} + +static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->default_fg; +} + +static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = 0xffffffff; +} + +static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_fg = ctx->default_fg_bright; +} + +static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + ctx->text_bg = ctx->default_bg_bright; +} + +static void draw_cursor(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) { + return; + } + + size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols; + + struct flanterm_fb_char c; + struct flanterm_fb_queue_item *q = ctx->map[i]; + if (q != NULL) { + c = q->c; + } else { + c = ctx->grid[i]; + } + uint32_t tmp = c.fg; + c.fg = c.bg; + c.bg = tmp; + ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y); + if (q != NULL) { + ctx->grid[i] = q->c; + ctx->map[i] = NULL; + } +} + +static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) { + + if (_ctx == NULL) + { + panic(NULL, "flanterm_fb_double_buffer_flush: _ctx is NULL"); + } + + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (_ctx->cursor_enabled) { + draw_cursor(_ctx); + } + + for (size_t i = 0; i < ctx->queue_i; i++) { + struct flanterm_fb_queue_item *q = &ctx->queue[i]; + size_t offset = q->y * _ctx->cols + q->x; + if (ctx->map[offset] == NULL) { + continue; + } + ctx->plot_char(_ctx, &q->c, q->x, q->y); + ctx->grid[offset] = q->c; + ctx->map[offset] = NULL; + } + + if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) { + if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) { + ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y); + } + } + + ctx->old_cursor_x = ctx->cursor_x; + ctx->old_cursor_y = ctx->cursor_y; + + ctx->queue_i = 0; + + if (ctx->flush_callback) { + ctx->flush_callback(ctx->framebuffer, ctx->pitch * ctx->phys_height); + } +} + +static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (ctx->cursor_x >= _ctx->cols) { + if (_ctx->wrap_enabled && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) { + ctx->cursor_x = 0; + ctx->cursor_y++; + if (ctx->cursor_y == _ctx->scroll_bottom_margin) { + ctx->cursor_y--; + flanterm_fb_scroll(_ctx); + } + if (ctx->cursor_y >= _ctx->rows) { + ctx->cursor_y = _ctx->rows - 1; + } + } else { + ctx->cursor_x = _ctx->cols - 1; + } + } + + struct flanterm_fb_char ch; + ch.c = c; + ch.fg = ctx->text_fg; + ch.bg = ctx->text_bg; + push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y); +} + +static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + uint32_t default_bg = ctx->default_bg; + + for (size_t y = 0; y < ctx->height; y++) { + for (size_t x = 0; x < ctx->width; x++) { + size_t px, py; + switch (ctx->rotation) { + default: + case FLANTERM_FB_ROTATE_0: + px = x; py = y; + break; + case FLANTERM_FB_ROTATE_90: + px = ctx->height - 1 - y; py = x; + break; + case FLANTERM_FB_ROTATE_180: + px = ctx->width - 1 - x; py = ctx->height - 1 - y; + break; + case FLANTERM_FB_ROTATE_270: + px = y; py = ctx->width - 1 - x; + break; + } + + if (ctx->canvas != NULL) { + ctx->framebuffer[py * (ctx->pitch / sizeof(uint32_t)) + px] = ctx->canvas[y * ctx->width + x]; + } else { + ctx->framebuffer[py * (ctx->pitch / sizeof(uint32_t)) + px] = default_bg; + } + } + } + + for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) { + size_t x = i % _ctx->cols; + size_t y = i / _ctx->cols; + + ctx->plot_char(_ctx, &ctx->grid[i], x, y); + } + + if (_ctx->cursor_enabled) { + draw_cursor(_ctx); + } + + if (ctx->flush_callback) { + ctx->flush_callback(ctx->framebuffer, ctx->pitch * ctx->phys_height); + } +} + +static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) { + struct flanterm_fb_context *ctx = (void *)_ctx; + + if (_free == NULL) { +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + if (bump_allocated_instance == true) { + bump_alloc_ptr = 0; + bump_alloc_base_offset_added = false; + bump_allocated_instance = false; + } +#endif + return; + } + + _free(ctx->font_bits, ctx->font_bits_size); + _free(ctx->font_bool, ctx->font_bool_size); + _free(ctx->grid, ctx->grid_size); + _free(ctx->queue, ctx->queue_size); + _free(ctx->map, ctx->map_size); + + if (ctx->canvas != NULL) { + _free(ctx->canvas, ctx->canvas_size); + } + + _free(ctx, sizeof(struct flanterm_fb_context)); +} + +struct flanterm_context *flanterm_fb_init( + void *(*_malloc)(size_t), + void (*_free)(void *, size_t), + uint32_t *framebuffer, size_t width, size_t height, size_t pitch, + uint8_t red_mask_size, uint8_t red_mask_shift, + uint8_t green_mask_size, uint8_t green_mask_shift, + uint8_t blue_mask_size, uint8_t blue_mask_shift, + uint32_t *canvas, + uint32_t *ansi_colours, uint32_t *ansi_bright_colours, + uint32_t *default_bg, uint32_t *default_fg, + uint32_t *default_bg_bright, uint32_t *default_fg_bright, + void *font, size_t font_width, size_t font_height, size_t font_spacing, + size_t font_scale_x, size_t font_scale_y, + size_t margin, + int rotation +) { + size_t phys_height = height; + + if (rotation == FLANTERM_FB_ROTATE_90 || rotation == FLANTERM_FB_ROTATE_270) { + size_t tmp = width; + width = height; + height = tmp; + } + + if (font_scale_x == 0 || font_scale_y == 0) { + font_scale_x = 1; + font_scale_y = 1; + if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) { + font_scale_x = 2; + font_scale_y = 2; + } + if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) { + font_scale_x = 4; + font_scale_y = 4; + } + } + + if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) { + return NULL; + } + + if (_malloc == NULL) { +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + if (bump_allocated_instance == true) { + return NULL; + } + _malloc = bump_alloc; + // Limit terminal size if needed + if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) { + size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width; + size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height; + + framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4))); + + width = width_limit; + height = height_limit; + } + + // Force disable canvas + canvas = NULL; +#else + return NULL; +#endif + } + + struct flanterm_fb_context *ctx = NULL; + ctx = _malloc(sizeof(struct flanterm_fb_context)); + if (ctx == NULL) { + goto fail; + } + + struct flanterm_context *_ctx = (void *)ctx; + memset(ctx, 0, sizeof(struct flanterm_fb_context)); + + ctx->red_mask_size = red_mask_size; + ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8); + ctx->green_mask_size = green_mask_size; + ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8); + ctx->blue_mask_size = blue_mask_size; + ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8); + + if (ansi_colours != NULL) { + for (size_t i = 0; i < 8; i++) { + ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]); + } + } else { + ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black + ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red + ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green + ctx->ansi_colours[3] = convert_colour(_ctx, 0x00aa5500); // brown + ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue + ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta + ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan + ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey + } + + if (ansi_bright_colours != NULL) { + for (size_t i = 0; i < 8; i++) { + ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]); + } + } else { + ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black + ctx->ansi_bright_colours[1] = convert_colour(_ctx, 0x00ff5555); // red + ctx->ansi_bright_colours[2] = convert_colour(_ctx, 0x0055ff55); // green + ctx->ansi_bright_colours[3] = convert_colour(_ctx, 0x00ffff55); // brown + ctx->ansi_bright_colours[4] = convert_colour(_ctx, 0x005555ff); // blue + ctx->ansi_bright_colours[5] = convert_colour(_ctx, 0x00ff55ff); // magenta + ctx->ansi_bright_colours[6] = convert_colour(_ctx, 0x0055ffff); // cyan + ctx->ansi_bright_colours[7] = convert_colour(_ctx, 0x00ffffff); // grey + } + + if (default_bg != NULL) { + ctx->default_bg = convert_colour(_ctx, *default_bg); + } else { + ctx->default_bg = 0x00000000; // background (black) + } + + if (default_fg != NULL) { + ctx->default_fg = convert_colour(_ctx, *default_fg); + } else { + ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey) + } + + if (default_bg_bright != NULL) { + ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright); + } else { + ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black) + } + + if (default_fg_bright != NULL) { + ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright); + } else { + ctx->default_fg_bright = convert_colour(_ctx, 0x00ffffff); // foreground (grey) + } + + ctx->text_fg = ctx->default_fg; + ctx->text_bg = 0xffffffff; + + ctx->rotation = rotation; + + ctx->framebuffer = (void *)framebuffer; + ctx->width = width; + ctx->height = height; + ctx->phys_height = phys_height; + ctx->pitch = pitch; + + // VGA fonts are always one byte per scanline regardless of font_width +#define FONT_BYTES (font_height * FLANTERM_FB_FONT_GLYPHS) + + if (font != NULL) { + ctx->font_width = font_width; + ctx->font_height = font_height; + ctx->font_bits_size = FONT_BYTES; + ctx->font_bits = _malloc(ctx->font_bits_size); + if (ctx->font_bits == NULL) { + goto fail; + } + memcpy(ctx->font_bits, font, ctx->font_bits_size); + } else { + ctx->font_width = font_width = 8; + ctx->font_height = font_height = 16; + ctx->font_bits_size = FONT_BYTES; + font_spacing = 1; + ctx->font_bits = _malloc(ctx->font_bits_size); + if (ctx->font_bits == NULL) { + goto fail; + } + memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size); + } + +#undef FONT_BYTES + + ctx->font_width += font_spacing; + + ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool); + ctx->font_bool = _malloc(ctx->font_bool_size); + if (ctx->font_bool == NULL) { + goto fail; + } + + for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) { + uint8_t *glyph = &ctx->font_bits[i * font_height]; + + for (size_t y = 0; y < font_height; y++) { + // NOTE: the characters in VGA fonts are always one byte wide. + // 9 dot wide fonts have 8 dots and one empty column, except + // characters 0xC0-0xDF replicate column 9. + for (size_t x = 0; x < 8; x++) { + size_t offset = i * font_height * ctx->font_width + y * ctx->font_width + x; + + if ((glyph[y] & (0x80 >> x))) { + ctx->font_bool[offset] = true; + } else { + ctx->font_bool[offset] = false; + } + } + // fill columns above 8 like VGA Line Graphics Mode does + for (size_t x = 8; x < ctx->font_width; x++) { + size_t offset = i * font_height * ctx->font_width + y * ctx->font_width + x; + + if (i >= 0xc0 && i <= 0xdf) { + ctx->font_bool[offset] = (glyph[y] & 1); + } else { + ctx->font_bool[offset] = false; + } + } + } + } + + ctx->font_scale_x = font_scale_x; + ctx->font_scale_y = font_scale_y; + + ctx->glyph_width = ctx->font_width * font_scale_x; + ctx->glyph_height = font_height * font_scale_y; + + _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width; + _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height; + + ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2; + ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2; + + ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char); + ctx->grid = _malloc(ctx->grid_size); + if (ctx->grid == NULL) { + goto fail; + } + for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) { + ctx->grid[i].c = ' '; + ctx->grid[i].fg = ctx->text_fg; + ctx->grid[i].bg = ctx->text_bg; + } + + ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item); + ctx->queue = _malloc(ctx->queue_size); + if (ctx->queue == NULL) { + goto fail; + } + ctx->queue_i = 0; + memset(ctx->queue, 0, ctx->queue_size); + + ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *); + ctx->map = _malloc(ctx->map_size); + if (ctx->map == NULL) { + goto fail; + } + memset(ctx->map, 0, ctx->map_size); + + if (canvas != NULL) { + ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t); + ctx->canvas = _malloc(ctx->canvas_size); + if (ctx->canvas == NULL) { + goto fail; + } + for (size_t i = 0; i < ctx->width * ctx->height; i++) { + ctx->canvas[i] = convert_colour(_ctx, canvas[i]); + } + } + + if (font_scale_x == 1 && font_scale_y == 1) { + if (canvas == NULL) { + ctx->plot_char = plot_char_unscaled_uncanvas; + } else { + ctx->plot_char = plot_char_unscaled_canvas; + } + } else { + if (canvas == NULL) { + ctx->plot_char = plot_char_scaled_uncanvas; + } else { + ctx->plot_char = plot_char_scaled_canvas; + } + } + + _ctx->raw_putchar = flanterm_fb_raw_putchar; + _ctx->clear = flanterm_fb_clear; + _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos; + _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos; + _ctx->set_text_fg = flanterm_fb_set_text_fg; + _ctx->set_text_bg = flanterm_fb_set_text_bg; + _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright; + _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright; + _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb; + _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb; + _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default; + _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default; + _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright; + _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright; + _ctx->move_character = flanterm_fb_move_character; + _ctx->scroll = flanterm_fb_scroll; + _ctx->revscroll = flanterm_fb_revscroll; + _ctx->swap_palette = flanterm_fb_swap_palette; + _ctx->save_state = flanterm_fb_save_state; + _ctx->restore_state = flanterm_fb_restore_state; + _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush; + _ctx->full_refresh = flanterm_fb_full_refresh; + _ctx->deinit = flanterm_fb_deinit; + + flanterm_context_reinit(_ctx); + flanterm_fb_full_refresh(_ctx); + +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + if (_malloc == bump_alloc) { + bump_allocated_instance = true; + } +#endif + + return _ctx; + +fail: + if (ctx == NULL) { + return NULL; + } + +#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC + if (_malloc == bump_alloc) { + bump_alloc_ptr = 0; + return NULL; + } +#endif + + if (_free == NULL) { + return NULL; + } + + if (ctx->canvas != NULL) { + _free(ctx->canvas, ctx->canvas_size); + } + if (ctx->map != NULL) { + _free(ctx->map, ctx->map_size); + } + if (ctx->queue != NULL) { + _free(ctx->queue, ctx->queue_size); + } + if (ctx->grid != NULL) { + _free(ctx->grid, ctx->grid_size); + } + if (ctx->font_bool != NULL) { + _free(ctx->font_bool, ctx->font_bool_size); + } + if (ctx->font_bits != NULL) { + _free(ctx->font_bits, ctx->font_bits_size); + } + if (ctx != NULL) { + _free(ctx, sizeof(struct flanterm_fb_context)); + } + + return NULL; +} + +void flanterm_fb_set_flush_callback(struct flanterm_context *_ctx, void (*flush_callback)(volatile void *address, size_t length)) { + struct flanterm_fb_context *ctx = (void *)_ctx; + ctx->flush_callback = flush_callback; +} diff --git a/src/io/term/flanterm_backends/fb.h b/src/io/term/flanterm_backends/fb.h new file mode 100644 index 0000000..bbc1810 --- /dev/null +++ b/src/io/term/flanterm_backends/fb.h @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/* Copyright (C) 2022-2026 Mintsuki and contributors. + * + * 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 HOLDER 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. + */ + +#ifndef FLANTERM_FB_H +#define FLANTERM_FB_H 1 + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#include "../flanterm.h" + +#ifdef FLANTERM_IN_FLANTERM + +#include "fb_private.h" + +#endif + +#define FLANTERM_FB_ROTATE_0 0 +#define FLANTERM_FB_ROTATE_90 1 +#define FLANTERM_FB_ROTATE_180 2 +#define FLANTERM_FB_ROTATE_270 3 + +struct flanterm_context *flanterm_fb_init( + /* If _malloc and _free are nulled, use the bump allocated instance (1 use only). */ + void *(*_malloc)(size_t size), + void (*_free)(void *ptr, size_t size), + uint32_t *framebuffer, size_t width, size_t height, size_t pitch, + uint8_t red_mask_size, uint8_t red_mask_shift, + uint8_t green_mask_size, uint8_t green_mask_shift, + uint8_t blue_mask_size, uint8_t blue_mask_shift, + uint32_t *canvas, /* If nulled, no canvas. */ + uint32_t *ansi_colours, uint32_t *ansi_bright_colours, /* If nulled, default. */ + uint32_t *default_bg, uint32_t *default_fg, /* If nulled, default. */ + uint32_t *default_bg_bright, uint32_t *default_fg_bright, /* If nulled, default. */ + /* If font is null, use default font and font_width and font_height ignored. */ + void *font, size_t font_width, size_t font_height, size_t font_spacing, + /* If scale_x and scale_y are 0, automatically scale font based on resolution. */ + size_t font_scale_x, size_t font_scale_y, + size_t margin, + /* One of FLANTERM_FB_ROTATE_* values. */ + int rotation +); + +void flanterm_fb_set_flush_callback(struct flanterm_context *ctx, void (*flush_callback)(volatile void *address, size_t length)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/io/term/flanterm_backends/fb_private.h b/src/io/term/flanterm_backends/fb_private.h new file mode 100644 index 0000000..e80df5b --- /dev/null +++ b/src/io/term/flanterm_backends/fb_private.h @@ -0,0 +1,127 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/* Copyright (C) 2022-2026 Mintsuki and contributors. + * + * 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 HOLDER 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. + */ + +#ifndef FLANTERM_FB_PRIVATE_H +#define FLANTERM_FB_PRIVATE_H 1 + +#ifndef FLANTERM_IN_FLANTERM +#error "Do not use fb_private.h. Use interfaces defined in fb.h only." +#endif + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define FLANTERM_FB_FONT_GLYPHS 256 + +struct flanterm_fb_char { + uint32_t c; + uint32_t fg; + uint32_t bg; +}; + +struct flanterm_fb_queue_item { + size_t x, y; + struct flanterm_fb_char c; +}; + +struct flanterm_fb_context { + struct flanterm_context term; + + void (*plot_char)(struct flanterm_context *ctx, struct flanterm_fb_char *c, size_t x, size_t y); + void (*flush_callback)(volatile void *address, size_t length); + + size_t font_width; + size_t font_height; + size_t glyph_width; + size_t glyph_height; + + size_t font_scale_x; + size_t font_scale_y; + + size_t offset_x, offset_y; + + volatile uint32_t *framebuffer; + size_t pitch; + size_t width; + size_t height; + size_t phys_height; + size_t bpp; + + uint8_t red_mask_size, red_mask_shift; + uint8_t green_mask_size, green_mask_shift; + uint8_t blue_mask_size, blue_mask_shift; + + int rotation; + + size_t font_bits_size; + uint8_t *font_bits; + size_t font_bool_size; + bool *font_bool; + + uint32_t ansi_colours[8]; + uint32_t ansi_bright_colours[8]; + uint32_t default_fg, default_bg; + uint32_t default_fg_bright, default_bg_bright; + + size_t canvas_size; + uint32_t *canvas; + + size_t grid_size; + size_t queue_size; + size_t map_size; + + struct flanterm_fb_char *grid; + + struct flanterm_fb_queue_item *queue; + size_t queue_i; + + struct flanterm_fb_queue_item **map; + + uint32_t text_fg; + uint32_t text_bg; + size_t cursor_x; + size_t cursor_y; + + uint32_t saved_state_text_fg; + uint32_t saved_state_text_bg; + size_t saved_state_cursor_x; + size_t saved_state_cursor_y; + + size_t old_cursor_x; + size_t old_cursor_y; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/io/term/flanterm_private.h b/src/io/term/flanterm_private.h new file mode 100644 index 0000000..86650c6 --- /dev/null +++ b/src/io/term/flanterm_private.h @@ -0,0 +1,133 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/* Copyright (C) 2022-2026 Mintsuki and contributors. + * + * 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 HOLDER 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. + */ + +#ifndef FLANTERM_PRIVATE_H +#define FLANTERM_PRIVATE_H 1 + +#ifndef FLANTERM_IN_FLANTERM +#error "Do not use flanterm_private.h. Use interfaces defined in flanterm.h only." +#endif + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define FLANTERM_MAX_ESC_VALUES 16 + +struct flanterm_context { + /* internal use */ + + size_t tab_size; + bool autoflush; + bool cursor_enabled; + bool scroll_enabled; + bool wrap_enabled; + bool origin_mode; + bool control_sequence; + bool escape; + bool osc; + bool osc_escape; + size_t osc_buf_i; + uint8_t osc_buf[256]; + bool rrr; + bool discard_next; + bool bold; + bool bg_bold; + bool reverse_video; + bool dec_private; + bool insert_mode; + bool csi_unhandled; + uint64_t code_point; + size_t unicode_remaining; + uint8_t g_select; + uint8_t charsets[2]; + size_t current_charset; + size_t escape_offset; + size_t esc_values_i; + size_t saved_cursor_x; + size_t saved_cursor_y; + size_t current_primary; + size_t current_bg; + size_t scroll_top_margin; + size_t scroll_bottom_margin; + uint32_t esc_values[FLANTERM_MAX_ESC_VALUES]; + uint8_t last_printed_char; + bool last_was_graphic; + bool saved_state_bold; + bool saved_state_bg_bold; + bool saved_state_reverse_video; + bool saved_state_origin_mode; + bool saved_state_wrap_enabled; + size_t saved_state_current_charset; + uint8_t saved_state_charsets[2]; + size_t saved_state_current_primary; + size_t saved_state_current_bg; + + /* to be set by backend */ + + size_t rows, cols; + + void (*raw_putchar)(struct flanterm_context *, uint8_t c); + void (*clear)(struct flanterm_context *, bool move); + void (*set_cursor_pos)(struct flanterm_context *, size_t x, size_t y); + void (*get_cursor_pos)(struct flanterm_context *, size_t *x, size_t *y); + void (*set_text_fg)(struct flanterm_context *, size_t fg); + void (*set_text_bg)(struct flanterm_context *, size_t bg); + void (*set_text_fg_bright)(struct flanterm_context *, size_t fg); + void (*set_text_bg_bright)(struct flanterm_context *, size_t bg); + void (*set_text_fg_rgb)(struct flanterm_context *, uint32_t fg); + void (*set_text_bg_rgb)(struct flanterm_context *, uint32_t bg); + void (*set_text_fg_default)(struct flanterm_context *); + void (*set_text_bg_default)(struct flanterm_context *); + void (*set_text_fg_default_bright)(struct flanterm_context *); + void (*set_text_bg_default_bright)(struct flanterm_context *); + void (*move_character)(struct flanterm_context *, size_t new_x, size_t new_y, size_t old_x, size_t old_y); + void (*scroll)(struct flanterm_context *); + void (*revscroll)(struct flanterm_context *); + void (*swap_palette)(struct flanterm_context *); + void (*save_state)(struct flanterm_context *); + void (*restore_state)(struct flanterm_context *); + void (*double_buffer_flush)(struct flanterm_context *); + void (*full_refresh)(struct flanterm_context *); + void (*deinit)(struct flanterm_context *, void (*)(void *, size_t)); + + /* to be set by client */ + + void (*callback)(struct flanterm_context *, uint64_t, uint64_t, uint64_t, uint64_t); +}; + +void flanterm_context_reinit(struct flanterm_context *ctx); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/io/term/term.c b/src/io/term/term.c index 98893ed..6d7b709 100644 --- a/src/io/term/term.c +++ b/src/io/term/term.c @@ -11,196 +11,18 @@ because this shitty implementation will be replaced one day by Flanterm (once memory management is okay: paging & kernel malloc) */ -#include #include #include #include "term.h" -#include "mem/misc/utils.h" #include "config.h" +#include "flanterm.h" -extern struct boot_context boot_ctx; - -// Importing the PSF object file -extern unsigned char _binary_zap_light16_psf_start[]; -extern unsigned char _binary_zap_light16_psf_end[]; - -PSF1_Header* font = (PSF1_Header*)_binary_zap_light16_psf_start; -uint8_t* glyphs = _binary_zap_light16_psf_start + sizeof(PSF1_Header); - -#define FONT_WIDTH 8 -#define FONT_HEIGHT font->characterSize - - - -// Character cursor -typedef struct -{ - size_t x; - size_t y; -} Cursor; - -static Cursor cursor = {0, 0}; - -static uint8_t* fb; -static struct limine_framebuffer* framebuffer; - -uint8_t lines_length[TERM_HISTORY_MAX_LINES]; - -static inline size_t term_max_cols(void) -{ - return framebuffer->width / FONT_WIDTH; -} - -static inline size_t term_max_lines(void) -{ - return framebuffer->height / FONT_HEIGHT; -} - -int term_init() -{ - // Get framebuffer address from Limine struct - - if (!boot_ctx.fb) - { - return -ENOMEM; - } - - framebuffer = boot_ctx.fb; - fb = (uint8_t*)framebuffer->address; - - memset(lines_length, 0, sizeof(lines_length)); - - DEBUG("terminal initialized, fb=0x%p (width=%u height=%u pitch=%u bpp=%u)", fb, framebuffer->width, framebuffer->height, framebuffer->pitch, framebuffer->bpp); - return 0; -} - -// These are marked "static" because we don't wanna expose them all around -// AKA they should just be seen here (kind of like private functions in cpp) -static inline void putpixel(size_t x, size_t y, uint32_t color) -{ - // Guard so we don't write past fb boundaries - if (x >= framebuffer->width || y >= framebuffer->height) return; - // Depth isn't part of limine_framebuffer attributes so it will be 4 - size_t pos = x*4 + y*framebuffer->pitch; - fb[pos] = color & 255; // blue channel - fb[pos+1] = (color >> 8) & 255; // green - fb[pos+2] = (color >> 16) & 255; // blue -} - -static void draw_char(char c, size_t px, size_t py, uint32_t fg, uint32_t bg) -{ - // So we cannot write past fb - if (px+FONT_WIDTH > framebuffer->width || py+FONT_HEIGHT > framebuffer->height) return; - - uint8_t* glyph = glyphs + ((unsigned char)c * FONT_HEIGHT); - - for (size_t y=0; y> x)) ? fg : bg; - putpixel(px+x, py+y, color); - } - } -} - -static void erase_char(size_t px, size_t py) -{ - if (px+FONT_WIDTH > framebuffer->width || py+FONT_HEIGHT > framebuffer->height) return; - - for (size_t y=0; ypitch); - - // Move whole framebuffer up by one text line - memmove(fb, fb+(FONT_HEIGHT*framebuffer->pitch), (framebuffer->height-FONT_HEIGHT)*framebuffer->pitch); - - // Clear last text line - size_t clear_start = (framebuffer->height - FONT_HEIGHT) * framebuffer->pitch; - memset(fb + clear_start, 255, FONT_HEIGHT * framebuffer->pitch); - - // Shift line lengths by 1 (for backspace handling) - size_t max_lines = term_max_lines(); - for (size_t i = 1; i < max_lines; i++) - { - lines_length[i - 1] = lines_length[i]; - } - lines_length[max_lines - 1] = 0; -} - -void putchar(char c) -{ - const size_t max_cols = term_max_cols(); - const size_t max_lines = term_max_lines(); - - if (c == '\n') { - lines_length[cursor.y] = cursor.x; - cursor.x = 0; - - if (cursor.y + 1 >= max_lines) - { - term_scroll(); - } - else - { - cursor.y++; - } - return; - } - - if (c == '\b') - { - if (cursor.x > 0) - { - cursor.x--; - } - else if (cursor.y > 0) - { - cursor.y--; - cursor.x = lines_length[cursor.y]; - } - else - { - return; - } - - erase_char(cursor.x * FONT_WIDTH, cursor.y * FONT_HEIGHT); - return; - } - - if (cursor.x >= max_cols) - { - cursor.x = 0; - if (cursor.y + 1 >= max_lines) - { - term_scroll(); - } - else - { - cursor.y++; - } - } - - draw_char(c, cursor.x * FONT_WIDTH, cursor.y * FONT_HEIGHT, WHITE, BLACK); - cursor.x++; -} +extern struct flanterm_context* ft_ctx; // Overhead that could be avoided, right? (for printf) void _putchar(char character) { - putchar(character); + flanterm_write(ft_ctx, &character, 1); } // Debug-printing @@ -209,7 +31,8 @@ void kputs(const char* str) size_t i=0; while (str[i] != 0) { - putchar(str[i]); + _putchar(str[i]); i++; } + _putchar('\r'); } \ No newline at end of file diff --git a/src/io/term/term.h b/src/io/term/term.h index 99c0cd9..26e89d0 100644 --- a/src/io/term/term.h +++ b/src/io/term/term.h @@ -7,26 +7,7 @@ #ifndef TERM_H #define TERM_H -int term_init(); void kputs(const char* str); -void putchar(char c); - -enum TermColors -{ - BLACK = 0x000000, - WHITE = 0xffffff -}; - -#define PSF1_FONT_MAGIC 0x0436 - -typedef struct -{ - uint16_t magic; - uint8_t fontMode; - uint8_t characterSize; // height -} PSF1_Header; - -// debug -void term_scroll(); +void _putchar(char character); #endif diff --git a/src/kernel.h b/src/kernel.h index 7d386f3..d901915 100644 --- a/src/kernel.h +++ b/src/kernel.h @@ -22,6 +22,12 @@ enum ErrorCodes #define DEBUG(log, ...) fctprintf((void*)&skputc, 0, "debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__) + +/* #define DEBUG(log, ...) \ + printf("debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__); \ + fctprintf((void*)&skputc, 0, "debug: [%s]: " log "\r\n", __FILE__, ##__VA_ARGS__) + */ + #define DIE_DEBUG(str) fctprintf((void*)&skputc, 0, str) #define CHECK_BIT(var,pos) ((var) & (1<<(pos))) @@ -34,6 +40,7 @@ void idle(); void debug_stack_trace(unsigned int max_frames); const char* debug_find_symbol(uintptr_t rip, uintptr_t* offset); +void boot_mem_display(); #define assert(check) do { if(!(check)) hcf(); } while(0) diff --git a/src/kmain.c b/src/kmain.c index e002fca..cb79c5e 100644 --- a/src/kmain.c +++ b/src/kmain.c @@ -23,11 +23,15 @@ #include "sched/process.h" #include "sched/scheduler.h" #include "config.h" +#include "io/term/flanterm.h" +#include "io/term/flanterm_backends/fb.h" // Limine version used __attribute__((used, section(".limine_requests"))) volatile LIMINE_BASE_REVISION(3); +struct flanterm_context *ft_ctx; + // Halt and catch fire (makes machine stall) void hcf() { @@ -37,7 +41,7 @@ void hcf() // Doing nothing (can be interrupted) void idle() {SET_INTERRUPTS; for(;;)asm("hlt");} -uint8_t kernel_stack[KERNEL_STACK_SIZE] __attribute__((aligned(16))); +// uint8_t kernel_stack[KERNEL_STACK_SIZE] __attribute__((aligned(16))); struct boot_context boot_ctx; @@ -51,12 +55,8 @@ extern struct process_t* current_process; void pedicel_main(void* arg) { - printf("Hello, world from a KERNEL PROCESS!"); -} - -void two_main(void* arg) -{ - printf("...process 2 speaking!!!"); + // FROM THE NEXT LINE ONWARDS, CANNOT WRITE TO FRAMEBUFFER WITHOUT PAGE FAULT! + //printf("\n\nWelcome to PepperOS! Pedicel speaking.\nNothing left to do, halting the system!"); } void idle_main(void* arg) @@ -64,41 +64,65 @@ void idle_main(void* arg) for(;;)asm("hlt"); } +void flanterm_free_wrapper(void* ptr, size_t size) +{ + (void)size; + kfree(ptr); +} + +extern uintptr_t kheap_start; + // This is our entry point void kmain() { + CLEAR_INTERRUPTS; if (!LIMINE_BASE_REVISION_SUPPORTED) hcf(); + serial_init(); + // Populate boot context boot_ctx.fb = framebuffer_request.response ? framebuffer_request.response->framebuffers[0] : NULL; boot_ctx.mmap = memmap_request.response ? memmap_request.response : NULL; boot_ctx.hhdm = hhdm_request.response ? hhdm_request.response : NULL; boot_ctx.kaddr = kerneladdr_request.response ? kerneladdr_request.response : NULL; - serial_init(); - - memmap_display(boot_ctx.mmap); - hhdm_display(boot_ctx.hhdm); - DEBUG("kernel: phys_base=0x%p virt_base=0x%p", boot_ctx.kaddr->physical_base, boot_ctx.kaddr->virtual_base); - - CLEAR_INTERRUPTS; - gdt_init(); - idt_init(); - timer_init(); - + boot_mem_display(); pmm_init(boot_ctx.mmap, boot_ctx.hhdm); // Remap kernel , HHDM and framebuffer paging_init(boot_ctx.kaddr, boot_ctx.fb); - kheap_init(); + keyboard_init(FR); + + uint32_t bgColor = 0x252525; + ft_ctx = flanterm_fb_init( + kmalloc, + flanterm_free_wrapper, + boot_ctx.fb->address, boot_ctx.fb->width, boot_ctx.fb->height, boot_ctx.fb->pitch, + boot_ctx.fb->red_mask_size, boot_ctx.fb->red_mask_shift, + boot_ctx.fb->green_mask_size, boot_ctx.fb->green_mask_shift, + boot_ctx.fb->blue_mask_size, boot_ctx.fb->blue_mask_shift, + NULL, + NULL, NULL, + &bgColor, NULL, // &bgColor + NULL, NULL, + NULL, 0, 0, 1, + 0, 0, + 0, + 0 + ); + + gdt_init(); + idt_init(); + + timer_init(); vmm_init(); + process_init(); struct process_t* idle_proc = process_create("idle", (void*)idle_main, 0); struct process_t* pedicel = process_create("pedicel", (void*)pedicel_main, 0); - struct process_t* two = process_create("two", (void*)two_main, 0); - + process_display_list(processes_list); scheduler_init(); @@ -106,11 +130,6 @@ void kmain() current_process = idle_proc; current_process->status = RUNNING; - SET_INTERRUPTS; - - keyboard_init(FR); - term_init(); kputs(PEPPEROS_SPLASH); - idle(); } diff --git a/src/mem/heap/kheap.c b/src/mem/heap/kheap.c index d3918f2..b97f344 100644 --- a/src/mem/heap/kheap.c +++ b/src/mem/heap/kheap.c @@ -23,40 +23,36 @@ static uintptr_t end; // Kernel root table (level 4) extern uint64_t *kernel_pml4; -static void kheap_grow(size_t size) -{ - size_t pages = ALIGN_UP(size + sizeof(struct heap_block_t), PAGE_SIZE) / PAGE_SIZE; - - if (pages == 0) pages = 1; - - for (size_t i = 0; i < pages; i++) - { - kheap_map_page(); - } -} - -void kheap_map_page() -{ - uintptr_t phys = pmm_alloc(); - paging_map_page(kernel_pml4, end, phys, PTE_PRESENT | PTE_WRITABLE | PTE_NOEXEC); - end += PAGE_SIZE; - //DEBUG("Mapped first kheap page"); -} - void kheap_init() { kheap_start = ALIGN_UP(kernel_virt_base + KERNEL_SIZE, PAGE_SIZE); - end = kheap_start; + + size_t heap_pages = ALIGN_UP(KHEAP_SIZE, PAGE_SIZE) / PAGE_SIZE; + DEBUG("Mapping %d kernel heap pages at 0x%p", heap_pages, kheap_start); - // At least 1 page must be mapped for it to work - kheap_map_page(); + uintptr_t current_addr = kheap_start; + + // Map/alloc enough pages for heap (KHEAP_SIZE) + for (size_t i=0; isize = PAGE_SIZE - sizeof(struct heap_block_t); + head->size = (end-kheap_start) - sizeof(struct heap_block_t); head->free = true; head->next = NULL; - DEBUG("kheap initialized, head=0x%p, size=%u", head, head->size); + DEBUG("Kernel heap initialized, head=0x%p, size=%u bytes", head, head->size); } void* kmalloc(size_t size) @@ -73,12 +69,12 @@ void* kmalloc(size_t size) if (curr->free && curr->size >= size) { // We split the block if it is big enough - if (curr->size >= size + BLOCK_MIN_SIZE) + if (curr->size >= size + sizeof(struct heap_block_t) + 16) { //struct heap_block_t* new_block = (struct heap_block_t*)((uintptr_t)curr + sizeof(struct heap_block_t) + size); - struct heap_block_t* split = (struct heap_block_t*)((uintptr_t)curr + sizeof(*curr) + size); + struct heap_block_t* split = (struct heap_block_t*)((uintptr_t)curr + sizeof(struct heap_block_t) + size); - split->size = curr->size - size - sizeof(*curr); + split->size = curr->size - size - sizeof(struct heap_block_t); split->free = true; split->next = curr->next; @@ -94,25 +90,12 @@ void* kmalloc(size_t size) curr = curr->next; } - // If we're here it means we didn't have enough memory - // for the block allocation. So we will allocate more.. - uintptr_t old_end = end; - kheap_grow(size + sizeof(struct heap_block_t)); - - struct heap_block_t* block = (struct heap_block_t*)old_end; - block->size = ALIGN_UP(end - old_end - sizeof(struct heap_block_t), 16); - block->free = true; - block->next = NULL; - - // Put the block at the end of the list - curr = head; - while (curr->next) - { - curr = curr->next; - } - curr->next = block; - - return kmalloc(size); + // No growing. If we're here it means the initial pool + // wasn't sufficient. Too bad. + DEBUG("Kernel heap is OUT OF MEMORY!"); + // if we were terrorists maybe we should panic + // or just wait for others to free stuff? + return NULL; } void kfree(void* ptr) diff --git a/src/mem/heap/kheap.h b/src/mem/heap/kheap.h index 111cf7b..e59b204 100644 --- a/src/mem/heap/kheap.h +++ b/src/mem/heap/kheap.h @@ -14,13 +14,15 @@ #include #include +#include struct heap_block_t { size_t size; - bool free; + bool free; // 1byte + uint8_t reserved[7]; // (7+1 = 8 bytes) struct heap_block_t* next; -}; +} __attribute__((aligned(16))); void kheap_init(); void* kmalloc(size_t size); diff --git a/src/mem/misc/utils.c b/src/mem/misc/utils.c index 8f7a43f..bdd5f07 100644 --- a/src/mem/misc/utils.c +++ b/src/mem/misc/utils.c @@ -76,53 +76,4 @@ int memcmp(const void* s1, const void* s2, size_t n) } return 0; -} - -// Display the memmap so we see how the memory is laid out at handoff -void memmap_display(struct limine_memmap_response* response) -{ - DEBUG("Got memory map from Limine: revision %u, %u entries", response->revision, response->entry_count); - - for (size_t i=0; ientry_count; i++) - { - struct limine_memmap_entry* entry = response->entries[i]; - char type[32] = {0}; - switch(entry->type) - { - case LIMINE_MEMMAP_USABLE: - strcpy(type, "USABLE"); - break; - case LIMINE_MEMMAP_RESERVED: - strcpy(type, "RESERVED"); - break; - case LIMINE_MEMMAP_ACPI_RECLAIMABLE: - strcpy(type, "ACPI_RECLAIMABLE"); - break; - case LIMINE_MEMMAP_ACPI_NVS: - strcpy(type, "ACPI_NVS"); - break; - case LIMINE_MEMMAP_BAD_MEMORY: - strcpy(type, "BAD_MEMORY"); - break; - case LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE: - strcpy(type, "BOOTLOADER_RECLAIMABLE"); - break; - case LIMINE_MEMMAP_KERNEL_AND_MODULES: - strcpy(type, "KERNEL_AND_MODULES"); - break; - case LIMINE_MEMMAP_FRAMEBUFFER: - strcpy(type, "FRAMEBUFFER"); - break; - default: - strcpy(type, "UNKNOWN"); - break; - } - DEBUG("entry %02u: [0x%016x | %016u bytes] - %s", i, entry->base, entry->length, type); - } -} - -// Display the HHDM -void hhdm_display(struct limine_hhdm_response* hhdm) -{ - DEBUG("Got HHDM revision=%u offset=0x%p", hhdm->revision, hhdm->offset); } \ No newline at end of file diff --git a/src/mem/paging/paging.c b/src/mem/paging/paging.c index c208e53..4128b14 100644 --- a/src/mem/paging/paging.c +++ b/src/mem/paging/paging.c @@ -123,7 +123,7 @@ void paging_init() DEBUG("Kernel lives at virt=0x%p phys=0x%p", kernel_virt_base, kernel_phys_base); kernel_pml4 = alloc_page_table(); - + // for debug uint64_t page_count = 0; @@ -187,6 +187,14 @@ void paging_init() } DEBUG("Mapped %u pages for framebuffer", page_count); + // test for flanterm + // When 10 pages are mapped, SOMETIMES (1 out of 50 times) it prints everything without problem! + // Other times it prints garbage (almost full cursors) and/or panics. +/* for (uint64_t i=0; i<10; i++) + { + paging_map_page(kernel_pml4, 0, kernel_phys_base+KERNEL_SIZE+i*PAGE_SIZE, PTE_WRITABLE); + } */ + // Finally, we load the physical address of our PML4 (root table) into cr3 load_cr3(VIRT_TO_PHYS(kernel_pml4)); DEBUG("cr3 loaded, we're still alive"); diff --git a/src/mem/paging/vmm.c b/src/mem/paging/vmm.c index f7f3256..3e989f9 100644 --- a/src/mem/paging/vmm.c +++ b/src/mem/paging/vmm.c @@ -68,5 +68,6 @@ void vmm_setup_pt_root() void vmm_init() { - vmm_setup_pt_root(); + // NO U + //vmm_setup_pt_root(); } \ No newline at end of file diff --git a/src/sched/process.c b/src/sched/process.c index 28945ad..e0fc25b 100644 --- a/src/sched/process.c +++ b/src/sched/process.c @@ -13,6 +13,9 @@ #include "config.h" #include "io/serial/serial.h" +#include "io/term/flanterm.h" +extern struct flanterm_context* ft_ctx; + struct process_t* processes_list; struct process_t* current_process; @@ -42,7 +45,7 @@ void process_display_list(struct process_t* processes_list) struct process_t* process_create(char* name, void(*function)(void*), void* arg) { - CLEAR_INTERRUPTS; +/* CLEAR_INTERRUPTS; */ struct process_t* proc = (struct process_t*)kmalloc(sizeof(struct process_t)); struct cpu_status_t* ctx = (struct cpu_status_t*)kmalloc(sizeof(struct cpu_status_t)); @@ -76,7 +79,7 @@ struct process_t* process_create(char* name, void(*function)(void*), void* arg) process_add(&processes_list, proc); - SET_INTERRUPTS; +/* SET_INTERRUPTS; */ return proc; } @@ -139,23 +142,6 @@ struct process_t* process_get_next(struct process_t* process) return process->next; } -// (from gdt) This will switch tasks ONLY in ring 0 -// KERNEL CS = 0x08 -// KERNEL SS = 0x10 -__attribute__((naked, noreturn)) -void process_switch(uint64_t stack_addr, uint64_t code_addr) -{ - asm volatile(" \ - push $0x10 \n\ - push %0 \n\ - push $0x202 \n\ - push $0x08 \n\ - push %1 \n\ - iretq \n\ - " :: "r"(stack_addr), "r"(code_addr)); -} - - // Will be used to clean up resources (if any, when we implement it) // Just mark as DEAD then idle. Scheduler will delete process at next timer interrupt % quantum. void process_exit() @@ -168,7 +154,7 @@ void process_exit() } SET_INTERRUPTS; - outb(0x20, 0x20); + //outb(0x20, 0x20); for (;;) { asm("hlt"); diff --git a/src/sched/process.h b/src/sched/process.h index f245728..5209e65 100644 --- a/src/sched/process.h +++ b/src/sched/process.h @@ -34,7 +34,6 @@ struct process_t* process_create(char* name, void(*function)(void*), void* arg); void process_add(struct process_t** processes_list, struct process_t* process); void process_delete(struct process_t** processes_list, struct process_t* process); struct process_t* process_get_next(struct process_t* process); -void process_switch(uint64_t stack_addr, uint64_t code_addr); void process_exit(); void process_display_list(struct process_t* processes_list); diff --git a/src/sched/scheduler.c b/src/sched/scheduler.c index 1e2e98d..e1b3299 100644 --- a/src/sched/scheduler.c +++ b/src/sched/scheduler.c @@ -21,8 +21,20 @@ void scheduler_init() struct cpu_status_t* scheduler_schedule(struct cpu_status_t* context) { + if (context == NULL) + { + panic(NULL, "Scheduler called with NULL context"); + } + + if (current_process == NULL) + { + // Wtf happened + current_process = processes_list; + //panic(NULL, "Scheduler called without current process"); + } + current_process->context = context; - current_process->status = READY; + //current_process->status = READY; for (;;) { struct process_t* prev_process = current_process; diff --git a/src/sched/task.S b/src/sched/task.S deleted file mode 100644 index 9aa669b..0000000 --- a/src/sched/task.S +++ /dev/null @@ -1,7 +0,0 @@ -; Task (process) switching - -bits 64 - -global switch_to_task -switch_to_task: - diff --git a/zap-light16.psf b/zap-light16.psf deleted file mode 100644 index 047bd1b..0000000 Binary files a/zap-light16.psf and /dev/null differ