├── rootfs
    ├── dev
    │   └── tmp
    ├── etc
    │   └── tmp
    ├── home
    │   ├── tmp
    │   └── root
    │   │   ├── no.txt
    │   │   └── yes.txt
    ├── usr
    │   └── tmp
    ├── var
    │   └── tmp
    └── yes.txt
├── include
    ├── ctype.h
    ├── math.h
    ├── audio
    │   └── pcspk.h
    ├── init.h
    ├── video
    │   ├── renderer.h
    │   └── video.h
    ├── debugout.h
    ├── memory
    │   ├── mem.h
    │   └── malloc.h
    ├── io.h
    ├── kernel.h
    ├── userinput
    │   ├── keyboard.h
    │   ├── mouse.h
    │   └── cursor.h
    ├── gpt.h
    ├── kernelDefines.h
    ├── time.h
    ├── arch
    │   └── x86
    │   │   └── registers.h
    ├── bootloader.h
    ├── idt
    │   ├── idt.h
    │   └── interrupts.h
    ├── gdt
    │   └── gdt.h
    ├── assert.h
    ├── tty.h
    ├── tty
    │   └── fbCon.h
    ├── acpi
    │   └── acpi.h
    ├── pci
    │   └── pci.h
    ├── string.h
    ├── stdio.h
    ├── fs
    │   └── ramfs.h
    ├── forceInclude.h
    ├── disks
    │   └── sata.h
    └── limine.h
├── font.old
├── kernel
    ├── gpt.c
    ├── gdt
    │   ├── gdtasm.asm
    │   └── gdt.c
    ├── video
    │   ├── renderer.c
    │   ├── video.c
    │   ├── fbcon.c
    │   ├── ansi.c
    │   ├── printf.h
    │   └── printf.c
    ├── audio
    │   └── pcspk.c
    ├── panic.c
    ├── kernel.c
    ├── boot
    │   ├── limine
    │   │   ├── check.c
    │   │   └── framebuffer.c
    │   └── checkLoader.c
    ├── tty.c
    ├── io.c
    ├── serial
    │   └── comout.c
    ├── log.c
    ├── idt
    │   ├── interrupts.c
    │   └── idt.c
    ├── memory
    │   ├── mem.c
    │   └── malloc.c
    ├── init.c
    ├── pci
    │   ├── pci.c
    │   └── pciDesc.c
    ├── time.c
    ├── fs
    │   └── ramfs.c
    ├── userinput
    │   ├── keyboard.c
    │   └── mouse.c
    ├── acpi
    │   └── acpi.c
    ├── string.c
    └── disks
    │   └── sata.c
├── vgafont.f16
├── OVMF_CODE.fd
├── tools
    ├── cursor.png
    ├── picsofbread.png
    ├── __pycache__
    │   ├── misc.cpython-310.pyc
    │   └── misc.cpython-39.pyc
    ├── iso.sh
    ├── misc.py
    ├── navcc.perl
    └── icontest
├── .gitignore
├── limine.cfg
├── README.md
├── linker.ld
├── Makefile
└── limine.h


/rootfs/dev/tmp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/rootfs/etc/tmp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/rootfs/home/tmp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/rootfs/usr/tmp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/rootfs/var/tmp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/rootfs/home/root/no.txt:
--------------------------------------------------------------------------------
1 | another test!
2 | 


--------------------------------------------------------------------------------
/include/ctype.h:
--------------------------------------------------------------------------------
1 | extern int isdigit(int ch);
2 | 


--------------------------------------------------------------------------------
/font.old:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/font.old


--------------------------------------------------------------------------------
/kernel/gpt.c:
--------------------------------------------------------------------------------
1 | //no. I did not implement ChatGPT into SeshOS
2 | #include <gpt.h>


--------------------------------------------------------------------------------
/vgafont.f16:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/vgafont.f16


--------------------------------------------------------------------------------
/OVMF_CODE.fd:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/OVMF_CODE.fd


--------------------------------------------------------------------------------
/tools/cursor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/tools/cursor.png


--------------------------------------------------------------------------------
/tools/picsofbread.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/tools/picsofbread.png


--------------------------------------------------------------------------------
/include/math.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | typedef struct {
4 |     uint64_t X;
5 |     uint64_t Y;
6 | } point_t;


--------------------------------------------------------------------------------
/include/audio/pcspk.h:
--------------------------------------------------------------------------------
1 | #include <stdint.h>
2 | 
3 | 
4 | void playSound(uint32_t nFrequence);
5 | void noSound();
6 | void beep();


--------------------------------------------------------------------------------
/tools/__pycache__/misc.cpython-310.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/tools/__pycache__/misc.cpython-310.pyc


--------------------------------------------------------------------------------
/tools/__pycache__/misc.cpython-39.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mine-man3000/SeshOS/HEAD/tools/__pycache__/misc.cpython-39.pyc


--------------------------------------------------------------------------------
/include/init.h:
--------------------------------------------------------------------------------
1 | #include <fs/ramfs.h>
2 | 
3 | #pragma once
4 | 
5 | /**
6 |  * @brief systemd but less bloated
7 |  */
8 | void init();


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.o
 2 | *.d
 3 | *.elf
 4 | limine/
 5 | iso_root/
 6 | initramfs
 7 | *.iso
 8 | .vscode
 9 | log.txt
10 | test.disk
11 | !kernel/boot/limine
12 | build/


--------------------------------------------------------------------------------
/include/video/renderer.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include <limine.h>
3 | #include <string.h>
4 | #include <math.h>
5 | 
6 | #define Green "\e[32m"
7 | #define Blue  "\e[34m"
8 | #define White "\e[37m"


--------------------------------------------------------------------------------
/include/debugout.h:
--------------------------------------------------------------------------------
1 | extern void comout(const char* input);
2 | extern void comout_num(uint64_t num);
3 | 
4 | extern void COM_LogWrapper(const char ch, const uint16_t x, const uint16_t y, const uint32_t fgColor, const uint32_t bgColor);


--------------------------------------------------------------------------------
/include/memory/mem.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stdint.h>
 4 | #include <stddef.h>
 5 | #include <kernel.h>
 6 | 
 7 | extern volatile struct limine_memmap_request mmap;
 8 | extern uint64_t physical_kernel_start;
 9 | 
10 | uint64_t getMemSize();
11 | int numPages();


--------------------------------------------------------------------------------
/include/io.h:
--------------------------------------------------------------------------------
1 | #include <stdint.h>
2 | void outb(uint16_t port, uint8_t value);
3 | uint8_t inb(uint16_t port);
4 | void outw (uint16_t port, uint16_t data);
5 | uint16_t inw (uint16_t port);
6 | void outl (uint16_t port, uint32_t data);
7 | uint32_t inl (uint32_t port);
8 | void io_wait();


--------------------------------------------------------------------------------
/tools/iso.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | xorriso -as mkisofs -b limine-bios-cd.bin -no-emul-boot -boot-load-size 4 -boot-info-table --efi-boot limine-uefi-cd.bin -efi-boot-part --efi-boot-image --protective-msdos-label iso_root -o bin/image.iso
3 | # I have to add a comment to have git play nice and push this file with the execute permission...
4 | 


--------------------------------------------------------------------------------
/kernel/gdt/gdtasm.asm:
--------------------------------------------------------------------------------
 1 | [bits 64]
 2 | LoadGDT: 
 3 |     lgdt [rdi]
 4 |     mov ax, 0x10 
 5 |     mov ds, ax
 6 |     mov es, ax
 7 |     mov fs, ax
 8 |     mov gs, ax
 9 |     mov ss, ax
10 |     pop rdi
11 |     mov rax, 0x08
12 |     push rax
13 |     push rdi
14 |     retfq
15 | GLOBAL LoadGDT
16 | 
17 | disablePIC: 
18 |     mov al, 0xff
19 |     out 0xa1, al
20 |     out 0x21, al
21 |     ret
22 | GLOBAL disablePIC


--------------------------------------------------------------------------------
/kernel/gdt/gdt.c:
--------------------------------------------------------------------------------
 1 | #include <gdt/gdt.h>
 2 | 
 3 | __attribute__((aligned(0x1000)))
 4 | GDT DefaultGDT = {
 5 |     {0, 0, 0, 0x00, 0x00, 0}, // null
 6 |     {0, 0, 0, 0x9a, 0xa0, 0}, // kernel code segment
 7 |     {0, 0, 0, 0x92, 0xa0, 0}, // kernel data segment
 8 |     {0, 0, 0, 0x00, 0x00, 0}, // user null
 9 |     {0, 0, 0, 0x9a, 0xa0, 0}, // kernel code segment
10 |     {0, 0, 0, 0x92, 0xa0, 0}, // kernel data segment
11 | };


--------------------------------------------------------------------------------
/include/memory/malloc.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stddef.h>
 4 | #include <stdbool.h>
 5 | 
 6 | extern void *malloc(size_t size);
 7 | extern void *realloc(char* ptr, size_t size);
 8 | extern void free(void *ptr);
 9 | extern void MEM_Init(unsigned char* addr);
10 | 
11 | extern bool kernieHeap_is_set_up;
12 | extern bool have_allocated;
13 | extern unsigned char *last_valid_address;
14 | extern unsigned char *kernieHeap_space;
15 | 


--------------------------------------------------------------------------------
/include/kernel.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <limine.h>
 3 | #include <video/renderer.h>
 4 | #include <string.h>
 5 | #include <video/video.h>
 6 | #include <init.h>
 7 | #include <memory/mem.h>
 8 | #include <time.h>
 9 | #include <idt/interrupts.h>
10 | 
11 | void comout(const char* input);
12 | void comout_num(uint64_t num);
13 | 
14 | extern struct limine_module_request module;
15 | extern struct limine_file* initramfs;
16 | void panic(const char *panicMessage, registers_t *regs);


--------------------------------------------------------------------------------
/include/userinput/keyboard.h:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | #include <string.h>
 3 | 
 4 | #define us_qwerty_left_shift	0x2A
 5 | #define us_qwerty_right_shift	0x36
 6 | #define us_qwerty_enter		0x1C
 7 | #define us_qwerty_backspace	0x0E
 8 | 
 9 | 
10 | extern uint8_t is_us_qwerty_left_shift_pressed;
11 | extern uint8_t is_us_qwerty_right_shift_pressed;
12 | 
13 | extern char us_qwerty_ascii_ps2_mapping[];
14 | 
15 | char get_us_qwerty_char_from_scan_code(uint8_t scan_code);
16 | void HandleKeyboard(uint8_t scancode);


--------------------------------------------------------------------------------
/limine.cfg:
--------------------------------------------------------------------------------
 1 | # Timeout in seconds that Limine will use before automatically booting.
 2 | TIMEOUT=0
 3 |  
 4 | # The entry name that will be displayed in the boot menu
 5 | :myOS
 6 |  
 7 | # Change the protocol line depending on the used protocol.
 8 | PROTOCOL=limine
 9 |  
10 | # Path to the kernel to boot. boot:/// represents the partition on which limine.cfg is located.
11 | KERNEL_PATH=boot:///kernel.elf
12 | 
13 | # Set the screen resolution
14 | # RESOLUTION=1600x900
15 | 
16 | MODULE_PATH=boot:///initramfs


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## BUILDING
 2 | 
 3 | install gcc, nasm, qemu-system-x86_64, qemu-uefi, xorriso, and make
 4 | 
 5 | for the debian/ubuntu/distros with APT, run ``sudo apt install build-essential qemu-system-x86 xorriso nasm``
 6 | 
 7 | then run ``make run`` and it will build and run the OS.
 8 | 
 9 | ## TODO
10 | - [X] Load an IDT so that exceptions and interrupts can be handled.
11 | - [X] Memory Management 
12 | - [ ] Scheduler 
13 | - [X] Start up the other CPU cores
14 | - [ ] VFS
15 | - [ ] Elf loader
16 | - [ ] Userland


--------------------------------------------------------------------------------
/tools/misc.py:
--------------------------------------------------------------------------------
 1 | import imageio as iio
 2 | from datetime import date
 3 | import os
 4 | import time
 5 | 
 6 | today = date.today()
 7 | 
 8 | dateRightFormat = str(today).split("-")
 9 | 
10 | day   = dateRightFormat[2]
11 | month = dateRightFormat[1]
12 | year  = dateRightFormat[0]
13 | 
14 | dateRightFormat[0] = month
15 | dateRightFormat[1] = day
16 | dateRightFormat[2] = year
17 | 
18 | newToday = "/".join(dateRightFormat)
19 | 
20 | finalDate = newToday[1]
21 | 
22 | #bread credit goes to https://www.picsofbread.com (tis the favicon)


--------------------------------------------------------------------------------
/include/gpt.h:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | 
 3 | typedef struct {
 4 |     uint64_t signature;
 5 |     uint32_t revision;
 6 |     uint32_t headerSize;
 7 |     uint32_t checksum;
 8 |     uint32_t reserved;
 9 |     uint64_t LBA;
10 |     uint64_t LBAAlt;
11 |     uint64_t firstUsableBlock;
12 |     uint64_t lastUsableBlock;
13 |     uint64_t guidPartOne;
14 |     uint64_t guidPartTwo;
15 |     uint64_t startLBA;
16 |     uint32_t numParts;
17 |     uint32_t entrySize;
18 |     uint32_t CRC32;
19 |     uint8_t a[420]; //hehe... nice
20 | } GPTTable;


--------------------------------------------------------------------------------
/include/kernelDefines.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <limine.h>
 4 | 
 5 | volatile struct limine_hhdm_request hhdm_request = {
 6 |     .id = LIMINE_HHDM_REQUEST,
 7 |     .revision = 0
 8 | };
 9 | uint64_t hhdm_offset;
10 | 
11 | volatile struct limine_kernel_address_request kernel_address_request = {
12 |     .id = LIMINE_KERNEL_ADDRESS_REQUEST,
13 |     .revision = 0
14 | };
15 | uint64_t physical_kernel_start;
16 | uint64_t virtual_kernel_start;
17 |  
18 | struct limine_module_request module = {
19 |     .id = LIMINE_MODULE_REQUEST,
20 |     .revision = 0
21 | };
22 | 


--------------------------------------------------------------------------------
/kernel/video/renderer.c:
--------------------------------------------------------------------------------
 1 | #include <video/renderer.h>
 2 | #include <video/video.h>
 3 | #include <tty/fbCon.h>
 4 | #include <tty.h>
 5 | #include <stdarg.h>
 6 | #include <kernel.h>
 7 | #include <memory/malloc.h>
 8 | 
 9 | #define PSF1_MAGIC0 0x36
10 | #define PSF1_MAGIC1 0x04
11 | 
12 | void putchar(char c) {
13 |     TTY_Write(c, TTY_CursorX, TTY_CursorY, TTY_Color, TTY_BgColor);
14 | }
15 | int puts(const char *string) {
16 |     const char *orig = string;
17 |     while (*string != '\0') {
18 |         putchar(*string);
19 |         string++;
20 |     }
21 |     return string - orig;
22 | }


--------------------------------------------------------------------------------
/include/time.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <stdint.h>
 3 | #include <stddef.h>
 4 | #include <idt/interrupts.h>
 5 | 
 6 | typedef struct {
 7 |     uint8_t  sec;
 8 |     uint8_t  min;
 9 |     uint8_t  hour;
10 |     uint8_t  weekDay;
11 |     uint8_t  day;
12 |     uint8_t  month;
13 |     uint16_t year;
14 | } time;
15 | 
16 | /**
17 |  * @brief Gets the current time from the RTC
18 |  * 
19 |  * @return the current time in a time struct
20 |  */
21 | time GetTime();
22 | 
23 | /**
24 |  * @brief sleeps for the given amount of seconds
25 |  * 
26 |  * @param seconds how long you want to sleep for
27 |  */
28 | void sleep(uint8_t seconds);


--------------------------------------------------------------------------------
/include/arch/x86/registers.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/log.h
 6 | ======================
 7 | */
 8 | 
 9 | #pragma once
10 | typedef struct {
11 | 	uint64_t rdi, rsi, rbp, rbx, rdx, rcx, rax;
12 | 	uint64_t r8, r9, r10, r11, r12, r13, r14, r15;
13 | 	uint64_t intNo, errCode;
14 | 	uint64_t rip, cs, rflags, rsp, ss;
15 | } __attribute__((packed)) registers_t;


--------------------------------------------------------------------------------
/include/bootloader.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/bootloader.h
 6 | ======================
 7 | */
 8 | 
 9 | #include <stdint.h>
10 | extern uint_fast8_t BOOT_LoaderID;
11 | extern char BOOT_LoaderName[64];
12 | extern char BOOT_LoaderVersion[64];
13 | 
14 | #define BOOT_LoaderID_Unknown 0
15 | #define BOOT_LoaderID_LimineCompatible 1
16 | 
17 | 
18 | extern void BOOT_CheckLoader();


--------------------------------------------------------------------------------
/kernel/audio/pcspk.c:
--------------------------------------------------------------------------------
 1 | #include <audio/pcspk.h>
 2 | #include <io.h>
 3 | #include <time.h>
 4 | 
 5 | void playSound(uint32_t nFrequence) {
 6 | 	uint32_t Div;
 7 | 	uint8_t tmp;
 8 | 
 9 | 	Div = 1193180 / nFrequence;
10 | 	outb(0x43, 0xb6);
11 | 	outb(0x42, (uint8_t) (Div) );
12 | 	outb(0x42, (uint8_t) (Div >> 8));
13 | 
14 | 	tmp = inb(0x61);
15 |  	if (tmp != (tmp | 3)) {
16 | 		outb(0x61, tmp | 3);
17 | 	}
18 | }
19 |  
20 | void noSound() {
21 |     uint8_t tmp = inb(0x61) & 0xFC;
22 | 	
23 |  	outb(0x61, tmp);
24 | }
25 |  
26 | void beep() {
27 |     for (int i = 1; i < 11; i++) {
28 |         playSound(i);
29 |         sleep(1);
30 |     }
31 |     noSound();
32 | }


--------------------------------------------------------------------------------
/kernel/panic.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdbool.h>
 3 | 
 4 | void panic(const char *panicMessage, registers_t *regs) {
 5 |     printf("Kernel Panic\n\n\r%s \n\n\rSeshOS has been shutdown to prevent damage to your computer", panicMessage);
 6 |     
 7 |     if (regs) {
 8 |         uint64_t cr2;
 9 |         asm("movq %%cr2, %0\r\n\r" : "=r" (cr2) : );
10 |         printf("\n\n\rDebug Info:\n\rRAX: 0x%lx\n\rRBX: 0x%lx\n\rRCX: 0x%lx\n\rRDX: 0x%lx\n\rRDI: 0x%lx\n\rRSI: 0x%lx\n\rRIP: 0x%lx\n\rCR2: 0x%lx", regs->rax, regs->rbx, regs->rcx, regs->rdx, regs->rdi, regs->rsi, regs->rip, cr2);        
11 |     }
12 | 
13 |     while (true) {
14 |         asm("cli; hlt");
15 |     }
16 | }


--------------------------------------------------------------------------------
/include/idt/idt.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <stdint.h>
 3 | 
 4 | #define int_ta_gate 0b10001110
 5 | #define int_ta_call_gate 0b10001100
 6 | #define int_ta_trap_gate 0b10001111
 7 | 
 8 | void create_idt();
 9 | 
10 | typedef struct
11 | {
12 | 	uint16_t offset_0;
13 | 	uint16_t selector;
14 | 	uint8_t stack_list_offset;
15 | 	uint8_t type_attribute;
16 | 	uint16_t offset_1;
17 | 	uint32_t offset_2;
18 | 	uint32_t ignore;
19 | } InterruptEntry;
20 | 
21 | void set_interrupt_offset(InterruptEntry* int_ptr, uint64_t offset);
22 | uint64_t get_interrupt_offset(InterruptEntry* int_ptr);
23 | 
24 | typedef struct __attribute__((packed))
25 | {
26 | 	uint16_t limit;
27 | 	uint64_t offset;
28 | } IDT;
29 | 
30 | extern IDT idt;


--------------------------------------------------------------------------------
/kernel/kernel.c:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | #include <stddef.h>
 3 | #include <kernel.h> 
 4 | #include <idt/interrupts.h>
 5 | #include <audio/pcspk.h>
 6 | #include <cpuid.h>
 7 | #include <acpi/acpi.h>
 8 | #include <stdio.h>
 9 | 
10 | 
11 | void * __gxx_personality_v0=0;
12 | void * _Unwind_Resume =0;
13 | void _comout(const char* input);
14 | 
15 | struct limine_file* initramfs;
16 | 
17 | volatile struct limine_smp_request smp = {
18 |     .id = LIMINE_SMP_REQUEST,
19 |     .revision = 0,
20 | };
21 | 
22 | 
23 | void _start(void) {
24 |     init();
25 | 
26 |     printf("Welcome to SeshOS\n\r");
27 | 
28 |     while (1) {
29 |         __asm__("hlt");
30 |     }    
31 | }
32 | 
33 | limine_goto_address halt() {
34 |     asm("cli;hlt");
35 | }


--------------------------------------------------------------------------------
/rootfs/yes.txt:
--------------------------------------------------------------------------------
 1 | SSSSSS   EEEEEE  SSSSSS  HH  HH
 2 | SSSSSS   EEEEEE  SSSSSS  HH  HH
 3 | SSS      EE      SSS     HH  HH
 4 | SSS      EE      SSS     HH  HH
 5 | SSSSSS   EEEEEE  SSSSSS  HHHHHH
 6 | SSSSSS   EEEEEE  SSSSSS  HHHHHH
 7 |    SSS   EE         SSS  HH  HH
 8 |    SSS   EE         SSS  HH  HH
 9 | SSSSSS   EEEEEE  SSSSSS  HH  HH
10 | SSSSSS   EEEEEE  SSSSSS  HH  HH
11 | 
12 |                  OOOOOO  SSSSSS
13 |     II  II       OO  OO  SSSSSS
14 |     II  II       OO  OO  SSS   
15 |     II  II       OO  OO  SSS   
16 |   \\      //     OO  OO  SSSSSS
17 |    \\====//      OO  OO  SSSSSS
18 |                  OO  OO     SSS
19 |                  OO  OO     SSS
20 |                  OO  OO  SSSSSS
21 |                  OOOOOO  SSSSSS
22 | 


--------------------------------------------------------------------------------
/include/gdt/gdt.h:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | 
 3 | typedef struct {
 4 |     uint16_t Size;
 5 |     uint64_t Offset;
 6 | } __attribute__((packed)) GDTDescriptor;
 7 | 
 8 | typedef struct {
 9 |     uint16_t Limit0;
10 |     uint16_t Base0;
11 |     uint8_t Base1;
12 |     uint8_t AccessByte;
13 |     uint8_t Limit1_Flags;
14 |     uint8_t Base2;
15 | }__attribute__((packed)) GDTEntry;
16 | 
17 | typedef struct {
18 |     GDTEntry Null; //0x00
19 |     GDTEntry KernelCode; //0x08
20 |     GDTEntry KernelData; //0x10
21 |     GDTEntry UserNull;
22 |     GDTEntry UserCode;
23 |     GDTEntry UserData;
24 | } __attribute__((packed)) 
25 | __attribute((aligned(0x1000))) GDT;
26 | 
27 | extern GDT DefaultGDT;
28 | 
29 | void LoadGDT(GDTDescriptor* gdtDescriptor);


--------------------------------------------------------------------------------
/include/userinput/mouse.h:
--------------------------------------------------------------------------------
 1 | #ifndef MOUSE_H
 2 | #define MOUSE_H
 3 | 
 4 | #include <video/renderer.h>
 5 | #include <math.h>
 6 | 
 7 | 
 8 | #define PS2Leftbutton 0b00000001
 9 | #define PS2Middlebutton 0b00000100
10 | #define PS2Rightbutton 0b00000010
11 | #define PS2XSign 0b00010000
12 | #define PS2YSign 0b00100000
13 | #define PS2XOverflow 0b01000000
14 | #define PS2YOverflow 0b10000000
15 | 
16 | extern bool LeftMouseDown;
17 | 
18 | void InitPS2Mouse();
19 | void HandlePS2Mouse(uint8_t data);
20 | void ProcessMousePacket();
21 | extern point_t MousePosition;
22 | 
23 | typedef struct {
24 |     point_t pos;
25 |     bool LeftDown;
26 |     bool RightDown;
27 |     bool MiddleDown;
28 | } Mouse;
29 | 
30 | extern Mouse GlobalMouse;
31 | 
32 | #endif


--------------------------------------------------------------------------------
/rootfs/home/root/yes.txt:
--------------------------------------------------------------------------------
 1 | SSSSSS   EEEEEE  SSSSSS  HH  HH
 2 | SSSSSS   EEEEEE  SSSSSS  HH  HH
 3 | SSS      EE      SSS     HH  HH
 4 | SSS      EE      SSS     HH  HH
 5 | SSSSSS   EEEEEE  SSSSSS  HHHHHH
 6 | SSSSSS   EEEEEE  SSSSSS  HHHHHH
 7 |    SSS   EE         SSS  HH  HH
 8 |    SSS   EE         SSS  HH  HH
 9 | SSSSSS   EEEEEE  SSSSSS  HH  HH
10 | SSSSSS   EEEEEE  SSSSSS  HH  HH
11 | 
12 |                  OOOOOO  SSSSSS
13 |     II  II       OO  OO  SSSSSS
14 |     II  II       OO  OO  SSS   
15 |     II  II       OO  OO  SSS   
16 |   \\      //     OO  OO  SSSSSS
17 |    \\====//      OO  OO  SSSSSS
18 |                  OO  OO     SSS
19 |                  OO  OO     SSS
20 |                  OO  OO  SSSSSS
21 |                  OOOOOO  SSSSSS
22 | 


--------------------------------------------------------------------------------
/include/assert.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/assert.h
 6 | ======================
 7 | */
 8 | 
 9 | 
10 | // #include <kernel/panic.h>
11 | #include <stdio.h>
12 | // #ifdef NDEBUG
13 | 	#define assert(expr) ((void)0)
14 | /*
15 | #else
16 | 	#define assert(expr)\
17 | 		if (!(expr)) {\
18 | 			DUMPREGS;\
19 | 			char __assertStr[100];\
20 | 			sprintf(__assertStr, "Assertion `%s' failed in file " __FILE__ ":%d\r\n", #expr, __LINE__);\
21 | 			panic(__assertStr, regs);\
22 | 		}
23 | #endif*/


--------------------------------------------------------------------------------
/kernel/boot/limine/check.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/bootloaders/limine/check.c
 6 | ======================
 7 | */
 8 | #include <limine.h>
 9 | #include <stdio.h>
10 | #include <stdbool.h>
11 | struct limine_bootloader_info_request bootloaderInfo = {
12 | 	.id = LIMINE_BOOTLOADER_INFO_REQUEST,
13 | 	.revision = 0
14 | };
15 | 
16 | 
17 | struct limine_bootloader_info_response *LM_Check() {
18 | 	// Check if we were actually booted by Limine.  Simple, see if we got a response from the "get info" request
19 | 	if (bootloaderInfo.response == NULL) {
20 | 		return NULL;
21 | 	}
22 | 	return bootloaderInfo.response;
23 | }


--------------------------------------------------------------------------------
/kernel/tty.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/tty.c
 6 | ======================
 7 | */
 8 | #include <stdint.h>
 9 | #include <stdbool.h>
10 | #include <tty.h>
11 | uint16_t TTY_CursorX;
12 | uint16_t TTY_CursorY;
13 | uint16_t TTY_Width;
14 | uint16_t TTY_Height;
15 | 
16 | uint32_t TTY_Color;
17 | uint32_t TTY_BgColor;
18 | 
19 | bool     TTY_Bold;
20 | 
21 | TTY_WriteFunc_t TTY_WriteFunc;
22 | 
23 | void TTY_SetWriteFunc(TTY_WriteFunc_t func) {
24 | 	TTY_WriteFunc = func;	
25 | }
26 | void TTY_Write(const char ch, const uint16_t x, const uint16_t y, const uint32_t fgColor, const uint32_t bgColor) {
27 | 	TTY_WriteFunc(ch, x, y, fgColor, bgColor);
28 | }


--------------------------------------------------------------------------------
/include/video/video.h:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | #include <stddef.h>
 3 | #include <limine.h>
 4 | #include <debugout.h>
 5 | 
 6 | /**
 7 |  * @brief draws a rectangle at the given position
 8 |  * 
 9 |  * @param startx where on the screen the top left most corner will be on the X axis
10 |  * @param starty where on the screen the top left most corner will be on the Y axis
11 |  * @param width  how wide the rectangle will be
12 |  * @param height how tall the rectangle will be
13 |  * @param VGA_COLOR the color of the rectangle given as 0xAARRGGBB (alpha, red, green, blue)
14 |  */
15 | void drawRect(int startx, int starty, int width, int height, uint32_t VGA_COLOR);
16 | void drawImage(uint32_t *icon, int posx, int posy);
17 | uint32_t *getImage(int posx, int posy, int width, int height);
18 | void Clear(uint32_t color);
19 | void putPixel(int x, int y, uint32_t pixel);
20 | uint32_t getPixel(uint32_t x, uint32_t y);
21 | 
22 | extern volatile struct limine_framebuffer_request framebuffer_request;


--------------------------------------------------------------------------------
/kernel/io.c:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | void outb(uint16_t port, uint8_t value) {
 3 |     asm volatile("outb %0, %1"
 4 |         :
 5 |         : "a"(value), "Nd"(port));
 6 | }
 7 | 
 8 | uint8_t inb(uint16_t port) {
 9 |     uint8_t returnVal;
10 |     asm volatile("inb %1, %0"
11 |         : "=a"(returnVal)
12 |         : "Nd"(port));
13 |     return returnVal;
14 | }
15 | 
16 | uint16_t inw (uint16_t port) {
17 |     uint16_t result;
18 |     asm("in %%dx, %%ax" : "=a" (result) : "d" (port));
19 |     return result;
20 | }
21 | 
22 | void outw (uint16_t port, uint16_t data) {
23 |     asm volatile("out %%ax, %%dx" : : "a" (data), "d" (port));
24 | }
25 | 
26 | uint32_t inl (uint32_t port) {
27 |     uint16_t result;
28 |     asm("in %%edx, %%eax" : "=a" (result) : "d" (port));
29 |     return result;
30 | }
31 | 
32 | void outl (uint16_t port, uint32_t data) {
33 |     asm volatile("out %%eax, %%edx" : : "a" (data), "d" (port));
34 | }
35 | 
36 | void io_wait() {
37 |     asm volatile("outb %%al, $0x80"
38 |         :
39 |         : "a"(0));
40 | }


--------------------------------------------------------------------------------
/include/tty.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/tty.h
 6 | ======================
 7 | */
 8 | #include <stdint.h>
 9 | #include <stdbool.h>
10 | 
11 | typedef void (*TTY_WriteFunc_t)(const char ch, const uint16_t x, const uint16_t y, const uint32_t fgColor, const uint32_t bgColor);
12 | 
13 | extern uint16_t TTY_CursorX;
14 | extern uint16_t TTY_CursorY;
15 | extern uint16_t TTY_Width;
16 | extern uint16_t TTY_Height;
17 | 
18 | extern uint32_t TTY_Color;
19 | extern uint32_t TTY_BgColor;
20 | 
21 | extern bool     TTY_Bold;
22 | 
23 | extern TTY_WriteFunc_t TTY_WriteFunc;
24 | 
25 | extern void TTY_SetWriteFunc(TTY_WriteFunc_t func);
26 | extern void TTY_Write(const char ch, const uint16_t x, const uint16_t y, const uint32_t fgColor, const uint32_t bgColor);
27 | extern bool TTY_HandleEsc(char ch);
28 | 


--------------------------------------------------------------------------------
/tools/navcc.perl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl
 2 | 
 3 | # Credit: nathanrsfba (NathanR#9714) on Discord
 4 | # Nathan's Amazing VGA to C Converter
 5 | # License: MIT
 6 | 
 7 | if( scalar( @ARGV ) != 1 ) {
 8 | 	die "Usage: $0 <fontfile>\n";
 9 | }
10 | 
11 | open my $fh, "<:raw", $ARGV[0];
12 | printf(
13 | "unsigned char font[256][16] = {
14 | 	{
15 | 		0b10101010,
16 | 		0b00000001,
17 | 		0b10111100,
18 | 		0b01100111,
19 | 		0b11100110,
20 | 		0b00001101,
21 | 		0b10011000,
22 | 		0b00011001,
23 | 		0b10011000,
24 | 		0b00011001,
25 | 		0b10000000,
26 | 		0b00111101,
27 | 		0b10111100,
28 | 		0b00000001,
29 | 		0b10000000,
30 | 		0b01010101
31 | 	}, {\r\n"
32 | );
33 | read $fh, my $junk, 16;
34 | for $i (0..254) {
35 | 	for $l (0..15) {
36 | 		read $fh, my $c, 1;
37 | 		# my $str = sprintf("%08b", ord($c));
38 | 		# why do I even neeed to do this...
39 | 		# printf( "\t\t0b%s", reverse($str) );
40 | 		printf("\t\t0b%08b", ord($c) );
41 | 		if ($l != 15) {
42 | 			print(",");
43 | 		}
44 | 
45 | 		print "\r\n";
46 | 	}
47 | 	if ($i != 254) {
48 | 		print "\t}, {\r\n";
49 | 	}
50 | }
51 | printf(
52 | "\t}
53 | };\r\n");


--------------------------------------------------------------------------------
/kernel/boot/limine/framebuffer.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/bootloaders/limine/framebuffer.c
 6 | ======================
 7 | */
 8 | #pragma GCC diagnostic push
 9 | #pragma GCC diagnostic ignored "-Wpadded"
10 | #include <limine.h>
11 | #pragma GCC diagnostic pop
12 | 
13 | #include <tty/fbCon.h>
14 | volatile struct limine_framebuffer_request fbRequest = {
15 | 	.id = LIMINE_FRAMEBUFFER_REQUEST,
16 | 	.revision = 0
17 | };
18 | 
19 | static framebuffer_t fbInfoLocal;
20 | 
21 | framebuffer_t LM_GetFramebuffer() {
22 | 	struct limine_framebuffer *res = fbRequest.response->framebuffers[0];
23 | 	fbInfoLocal.ptr    = (uint32_t *)res->address;
24 | 	fbInfoLocal.width  = (uint32_t)res->width;
25 | 	fbInfoLocal.height = (uint32_t)res->height;
26 | 	fbInfoLocal.pitch  = (uint64_t)res->pitch;
27 | 
28 | 	fbInfoLocal.mode = FB_MODE_RGBA;
29 | 
30 | 	return fbInfoLocal;
31 | }


--------------------------------------------------------------------------------
/include/tty/fbCon.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/tty/fbCon.h
 6 | ======================
 7 | */
 8 | 
 9 | #include <math.h>
10 | 
11 | typedef struct {
12 | 	uint32_t width;
13 | 	uint32_t height;
14 | 
15 | 	enum {
16 | 		FB_MODE_ARGB,
17 | 		FB_MODE_RGBA,
18 | 		FB_MODE_BGRA
19 | 	} mode;
20 | 
21 | 	uint32_t padding1;
22 | 	uint32_t *ptr;
23 | 	uint64_t pitch;
24 | } framebuffer_t;
25 | 
26 | extern uint8_t font[256][16];
27 | 
28 | 
29 | extern framebuffer_t fbCon;
30 | extern void FBCON_Init();
31 | 
32 | #define COLOR_WHITE  0xFFFFFFFF
33 | #define COLOR_BLACK  0xFF000000
34 | #define COLOR_RED    0xFFAA0000
35 | #define COLOR_GREEN  0xFF00AA00
36 | #define COLOR_BLUE   0xFF0000AA
37 | #define COLOR_CYAN   0xFF00AAAA
38 | #define COLOR_PURPLE 0xFFAA00AA
39 | #define COLOR_LGRAY  0xFFAAAAAA
40 | #define COLOR_YELLOW 0xFFAA5500
41 | 
42 | void DrawOverlayMouseCursor(point_t position);
43 | void ClearMouseCursor(point_t position);


--------------------------------------------------------------------------------
/kernel/serial/comout.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/COM.c
 6 | ======================
 7 | */
 8 | #include <stdint.h>
 9 | #include <io.h>
10 | #include <tty.h>
11 | 
12 | void comout(const char* input) {
13 |     int i = 0;
14 |     while (input[i] != '\0') {
15 |         outb(0xE9, input[i]);
16 |         i++;
17 |     }
18 | }
19 | 
20 | void comout_num(uint64_t num) {
21 |     for (int i = 0; i < 16; i ++) {
22 |         const char buf[2] = {"0123456789abcdef"[num >> 60], 0};
23 |         comout(&buf[0]);
24 |         num <<= 4;
25 |     }
26 | }
27 | 
28 | void COM_LogWrapper(const char ch, const uint16_t x, const uint16_t y, const uint32_t fgColor, const uint32_t bgColor) {
29 |     (void)x;
30 | 	(void)y;
31 | 	(void)fgColor;
32 | 	(void)bgColor;
33 |     comout((const char[]){ch, '\0'});
34 | 
35 |     if (ch == '\r') {
36 | 		TTY_CursorX = 0;
37 | 		return;
38 | 	}
39 | 	if (ch == '\n') {
40 | 		TTY_CursorY++;
41 | 		return;
42 | 	}
43 | 	TTY_CursorX++;
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/include/acpi/acpi.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <stdint.h>
 3 | 
 4 | typedef struct {
 5 | 	char signature[8];
 6 | 	uint8_t checksum;
 7 | 	char OEMId[6];
 8 | 	uint8_t revision;
 9 | 	uint32_t RSDTAddress;
10 | } __attribute__ ((packed)) RSDPDescriptor;
11 | 
12 | typedef struct {
13 | 	RSDPDescriptor firstPart;
14 | 	
15 | 	uint32_t len;
16 | 	uint64_t XSTDAddress;
17 | 	uint8_t extendedChecksum;
18 | 	uint8_t reserved[3];
19 | } __attribute__ ((packed)) RSDPDescriptor20;
20 | 
21 | typedef struct {
22 | 	char signature[4];
23 | 	uint32_t length;
24 | 	uint8_t revision;
25 | 	uint8_t checksum;
26 | 	char OEMId[6];
27 | 	char OEMTableID[8];
28 | 	uint32_t OEMRevision;
29 | 	uint32_t creatorID;
30 | 	uint32_t creatorRevision;
31 | } __attribute__ ((packed)) ACPISDTHeader;
32 | typedef struct {
33 | 	ACPISDTHeader h;
34 | 	// (h.length - sizeof(h)) / 4
35 | 	uint32_t pointerToOtherSDT[];
36 | } __attribute__ ((packed)) RSDT;
37 | 
38 | typedef struct {
39 |     ACPISDTHeader Header;
40 |     uint64_t Reserved;
41 | }__attribute__((packed)) MCFGHeader;
42 | 
43 | typedef struct {
44 |     uint64_t BaseAddress;
45 |     uint16_t PCISegGroup;
46 |     uint8_t StartBus;
47 |     uint8_t EndBus;
48 |     uint32_t Reserved;
49 | }__attribute__((packed)) DeviceConfig;
50 | 
51 | extern MCFGHeader* mcfg; 
52 | extern void ACPI_Init();


--------------------------------------------------------------------------------
/kernel/log.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/logging.c
 6 | ======================
 7 | */
 8 | 
 9 | #include <stdint.h>
10 | #include <stdio.h>
11 | #include <stdlib.h>
12 | #include <string.h>
13 | #include <debugout.h>
14 | #include <tty.h>
15 | static char *ansiColors[] = {
16 | 	"\e[0m",       // verbose
17 | 	"\e[0m",       // debug
18 | 	"\e[37m",      // info
19 | 	"\e[33m",      // warn
20 | 	"\e[0;31m",    // error
21 | 	"\e[31m !!! "  // fatal
22 | };
23 | void _log(const char module[8], const char *msg, const uint8_t level) {
24 | 	if (TTY_CursorX != 0) {
25 | 		puts("");
26 | 	}
27 | 	(void)level;
28 | 	// NOTE: we do this so that GCC can check the format
29 | 	#define fmt "\e[1m\e[33m[\e[36m%-*s\e[1m\e[33m]%s %s", 8
30 | 
31 | 	// are we still in early boot where the write func is set to serial?
32 | 	char str[256];
33 | 	sprintf(str, fmt, module, ansiColors[level], msg);
34 | 	if (level == LOGLEVEL_FATAL) {
35 | 		strcat(str, " !!!");
36 | 	}
37 | 	strcat(str, "\e[0m\r\n");
38 | 
39 | 	if (((void *)TTY_WriteFunc) != ((void *)COM_LogWrapper)) {
40 | 		// no, write it to serial manually, as well as to whatever the current output is
41 | 		comout(str);
42 | 	}
43 | 	// yes, just write it to serial
44 | 	printf("%s", str);
45 | }


--------------------------------------------------------------------------------
/include/pci/pci.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stdint.h>
 4 | #include <memory/mem.h>
 5 | #include <video/renderer.h>
 6 | #include <string.h>
 7 | #include <acpi/acpi.h>
 8 | 
 9 | typedef struct {
10 |     uint16_t VendorID;
11 |     uint16_t DeviceID;
12 |     uint16_t Command;
13 |     uint16_t Status;
14 |     uint8_t RevisionID;
15 |     uint8_t ProgIF;
16 |     uint8_t Subclass;
17 |     uint8_t Class;
18 |     uint8_t CacheLineSize;
19 |     uint8_t LatencyTimer;
20 |     uint8_t HeaderType;
21 |     uint8_t BIST;
22 | } __attribute__((packed)) PCIDeviceHeader;
23 | 
24 | typedef struct {
25 |     PCIDeviceHeader Header;
26 |     uint32_t BAR0;
27 |     uint32_t BAR1;
28 |     uint32_t BAR2;
29 |     uint32_t BAR3;
30 |     uint32_t BAR4;
31 |     uint32_t BAR5;
32 |     uint32_t CardbusCISPtr;
33 |     uint16_t SubsystemVendorID;
34 |     uint16_t SubsystemID;
35 |     uint32_t ExpansionROMBaseAddr;
36 |     uint8_t CapabilitiesPtr;
37 |     uint8_t Rsv0;
38 |     uint16_t Rsv1;
39 |     uint32_t Rsv2;
40 |     uint8_t InterruptLine;
41 |     uint8_t InterruptPin;
42 |     uint8_t MinGrant;
43 |     uint8_t MaxLatency;
44 | } __attribute__((packed)) PCIHeader0;
45 | 
46 | void EnumeratePCI(MCFGHeader *mcfg);
47 | 
48 | extern const char *DeviceClasses[];
49 | 
50 | const char *GetVendorName(uint16_t vendorID);
51 | const char *GetDeviceName(uint16_t vendorID, uint16_t deviceID);
52 | const char *GetSubclassName(uint8_t classCode, uint8_t subclassCode);
53 | const char *GetProgIFName(uint8_t classCode, uint8_t subclassCode, uint8_t progIF);


--------------------------------------------------------------------------------
/include/idt/interrupts.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <video/video.h>
 3 | #include <video/renderer.h>
 4 | #include <debugout.h>
 5 | 
 6 | #define PIC1_COMMAND 0x20
 7 | #define mastr_pic_cmnd_port 0x20
 8 | #define slave_pic_cmnd_port 0xA0
 9 | #define mastr_pic_data_port 0x21
10 | #define slave_pic_data_port 0xA1
11 | 
12 | #define PIC1_COMMAND 0x20
13 | #define PIC1_DATA 0x21
14 | #define PIC2_COMMAND 0xA0
15 | #define PIC2_DATA 0xA1
16 | #define PIC_EOI 0x20
17 | 
18 | #define icw1_init 0x10
19 | #define icw1_icw4 0x01
20 | #define icw4_8086 0x01
21 | 
22 | #define pic_eoi 0x20
23 | 
24 | void remap_interrupts_for_io();
25 | 
26 | void end_interrupts_for_mastr_io();
27 | void end_interrupts_for_slave_io();
28 | 
29 | typedef struct {
30 | 	uint64_t rdi, rsi, rbp, rbx, rdx, rcx, rax;
31 | 	uint64_t r8, r9, r10, r11, r12, r13, r14, r15;
32 | 	uint64_t intNo, errCode;
33 | 	uint64_t rip, cs, rflags, userRsp, ss;
34 | } interrupt_frame;
35 | 
36 | 
37 | __attribute__((interrupt)) void DivideByZero_Handler(interrupt_frame* frame);
38 | __attribute__((interrupt)) void PageFault_Handler(interrupt_frame* frame);
39 | __attribute__((interrupt)) void DoubleFault_Handler(interrupt_frame* frame);
40 | __attribute__((interrupt)) void GPFault_Handler(interrupt_frame* frame);
41 | __attribute__((interrupt)) void Keyboard_Handler(interrupt_frame* frame);
42 | __attribute__((interrupt)) void MouseInt_Handler(interrupt_frame* frame);
43 | __attribute__((interrupt)) void Test_Handler(interrupt_frame* frame);
44 | 
45 | void RemapPIC();
46 | void PIC_EndMaster();
47 | void PIC_EndSlave();


--------------------------------------------------------------------------------
/linker.ld:
--------------------------------------------------------------------------------
 1 | /* Tell the linker that we want an x86_64 ELF64 output file */
 2 | OUTPUT_FORMAT(elf64-x86-64)
 3 | OUTPUT_ARCH(i386:x86-64)
 4 |  
 5 | /* We want the symbol _start to be our entry point */
 6 | ENTRY(_start)
 7 |  
 8 | /* Define the program headers we want so the bootloader gives us the right */
 9 | /* MMU permissions */
10 | PHDRS
11 | {
12 |     null    PT_NULL    FLAGS(0) ;                   /* Null segment */
13 |     text    PT_LOAD    FLAGS((1 << 0) | (1 << 2)) ; /* Execute + Read */
14 |     rodata  PT_LOAD    FLAGS((1 << 2)) ;            /* Read only */
15 |     data    PT_LOAD    FLAGS((1 << 1) | (1 << 2)) ; /* Write + Read */
16 | }
17 |  
18 | SECTIONS
19 | {
20 |     /* We wanna be placed in the topmost 2GiB of the address space, for optimisations */
21 |     /* and because that is what the Limine spec mandates. */
22 |     /* Any address in this region will do, but often 0xffffffff80000000 is chosen as */
23 |     /* that is the beginning of the region. */
24 |     . = 0xffffffff80000000;
25 | 
26 |     kernel_start = .;
27 | 
28 |     .text : {
29 |         *(.text .text.*)
30 |     } :text
31 |  
32 |     /* Move to the next memory page for .rodata */
33 |     . += CONSTANT(MAXPAGESIZE);
34 |  
35 |     .rodata : {
36 |         *(.rodata .rodata.*)
37 |     } :rodata
38 |  
39 |     /* Move to the next memory page for .data */
40 |     . += CONSTANT(MAXPAGESIZE);
41 |  
42 |     .data : {
43 |         *(.data .data.*)
44 |     } :data
45 |  
46 |     .bss : {
47 |         *(COMMON)
48 |         *(.bss .bss.*)
49 |     } :data
50 | 
51 | 	kernel_end = .;
52 | }


--------------------------------------------------------------------------------
/kernel/idt/interrupts.c:
--------------------------------------------------------------------------------
 1 | #include <idt/interrupts.h>
 2 | #include <video/video.h>
 3 | #include <userinput/keyboard.h>
 4 | #include <userinput/mouse.h>
 5 | #include <debugout.h>
 6 | #include <io.h>
 7 | #include <stdio.h>
 8 | 
 9 | extern void panic(const char *panicMessage, interrupt_frame *regs);
10 | 
11 | extern void PIC_EndMaster();
12 | extern void PIC_EndSlave();
13 | 
14 | __attribute__((interrupt)) void DivideByZero_Handler(interrupt_frame* frame) {
15 |     panic("You can't divide by 0 silly :P", frame);
16 | }
17 | 
18 | __attribute__((interrupt)) void PageFault_Handler(interrupt_frame* frame) {
19 |     panic("Page Fault Detected", frame);
20 | }
21 | 
22 | __attribute__((interrupt)) void DoubleFault_Handler(interrupt_frame* frame) {
23 |     panic("Double Fault Detected", frame);
24 | }
25 | 
26 | __attribute__((interrupt)) void GPFault_Handler(interrupt_frame* frame) {
27 |     panic("General Protection Fault Detected", frame);
28 | }
29 | 
30 | __attribute__((interrupt)) void Keyboard_Handler(interrupt_frame* frame) {
31 |     uint8_t scancode = inb(0x60);
32 |     HandleKeyboard(scancode);
33 |     PIC_EndMaster();
34 | }
35 | 
36 | __attribute__((interrupt)) void MouseInt_Handler(interrupt_frame* frame)
37 | {
38 |     uint8_t mouseData = inb(0x60);
39 |     HandlePS2Mouse(mouseData);
40 |     PIC_EndSlave();
41 | }
42 | 
43 | __attribute__((interrupt)) void Test_Handler(interrupt_frame* frame) {
44 |     printf("NICE\n");
45 | }
46 | 
47 | void PIC_EndMaster(){
48 |     outb(PIC1_COMMAND, PIC_EOI);
49 | }
50 | 
51 | void PIC_EndSlave(){
52 |     outb(PIC2_COMMAND, PIC_EOI);
53 |     outb(PIC1_COMMAND, PIC_EOI);
54 | }


--------------------------------------------------------------------------------
/kernel/boot/checkLoader.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/bootloaders/check.c
 6 | ======================
 7 | */
 8 | #include <stdbool.h>
 9 | #include <stdio.h>
10 | #include <string.h>
11 | #include <limine.h>
12 | #include <bootloader.h>
13 | 
14 | uint_fast8_t BOOT_LoaderID;
15 | char BOOT_LoaderName[64];
16 | char BOOT_LoaderVersion[64];
17 | 
18 | extern struct limine_bootloader_info_response *LM_Check();
19 | MODULE("BOOTDTCT");
20 | 
21 | void BOOT_CheckLoader() {
22 | 	log("=== Autodetecting Bootloader ===", LOGLEVEL_INFO);
23 | 
24 | 	char str[128];
25 | 	strcpy(str, "Limine... ");
26 | 	struct limine_bootloader_info_response *limineData = LM_Check();
27 | 
28 | 	if (limineData != NULL) {
29 | 		strcat(str, "YES");
30 | 		log(str, LOGLEVEL_INFO);
31 | 
32 | 		sprintf(str, "Found Limine compatible bootloader, named \"%s\", with version \"%s\"", limineData->name, limineData->version);
33 | 		log(str, LOGLEVEL_INFO);
34 | 
35 | 		if (strlen(limineData->name) <= 64) {
36 | 			strcpy(BOOT_LoaderName, limineData->name);
37 | 		}
38 | 		else {
39 | 			memcpy(BOOT_LoaderName, limineData->name, 64);
40 | 		}
41 | 
42 | 		if (strlen(limineData->version) <= 64) {
43 | 			strcpy(BOOT_LoaderVersion, limineData->version);
44 | 		}
45 | 		else {
46 | 			memcpy(BOOT_LoaderVersion, limineData->version, 64);
47 | 		}
48 | 
49 | 		BOOT_LoaderID = BOOT_LoaderID_LimineCompatible;	
50 | 		
51 | 		return;
52 | 	}
53 | 	strcat(str, "NO");
54 | 	log(str, LOGLEVEL_INFO);
55 | 
56 | 	// TODO: Check for other bootloaders
57 | 
58 | 	log("No known bootloader detected!  Disabling bootloader-specific features.", LOGLEVEL_WARN);
59 | }


--------------------------------------------------------------------------------
/kernel/memory/mem.c:
--------------------------------------------------------------------------------
 1 | #include <memory/mem.h>
 2 | 
 3 | bool kernieHeap_is_set_up = false;
 4 | bool have_allocated = false;
 5 | unsigned char *last_valid_address;
 6 | unsigned char *kernieHeap_space;
 7 | volatile struct limine_memmap_request mmap = {
 8 |     .id = LIMINE_MEMMAP_REQUEST,
 9 |     .revision = 0,
10 | };
11 | 
12 | uint64_t getMemSize() {
13 |     uint64_t memSize = 0;
14 |     for (uint64_t i = 0; i < mmap.response->entry_count; i++) {
15 |         memSize += mmap.response->entries[i]->length;
16 |     }
17 |     return memSize; 
18 | }
19 | 
20 | void *memset(void *b, int c, int len) {
21 | 	uint8_t *p = (uint8_t*)b;
22 | 	while (len > 0) {
23 | 		*p = c;
24 | 		p++;
25 | 		len--;
26 | 	}
27 | 	return b;
28 | }
29 | void *memcpy(void* destination, const void* source, size_t num) {
30 | 	// Convert to char* for easy access
31 | 	char *src  = (char *)source;
32 | 	char *dest = (char *)destination;
33 | 
34 | 	// Copy bytes
35 | 	for (size_t i = 0; i < num; i++) {
36 | 		dest[i] = src[i];
37 | 	}
38 | 	return destination;
39 | }
40 | 
41 | int memcmp(const void *s1, const void *s2, int_fast64_t len) {
42 | 	const uint8_t *p = s1;
43 | 	const uint8_t *q = s2;
44 | 	int charCompareStatus = 0;
45 | 	// If both pointer pointing same memory block
46 | 	if (s1 == s2) {
47 | 		return charCompareStatus;
48 | 	}
49 | 	while (len > 0) {
50 | 		if (*p != *q) {
51 | 			// compare the mismatching character
52 | 			charCompareStatus = (*p > *q) ? 1 : -1;
53 | 			break;
54 | 		}
55 | 		len--;
56 | 		p++;
57 | 		q++;
58 | 	}
59 | 	return charCompareStatus;
60 | }
61 | 
62 | int numPages() {
63 |     int pageCount = 0;
64 |     for (uint64_t i = 0; i < mmap.response->entry_count; i++) {
65 |         if (mmap.response->entries[i]->length > 4096) {
66 |             pageCount += mmap.response->entries[i]->length / 4194304;
67 |         }
68 |         else {
69 |             pageCount++;
70 |         }
71 |     }
72 |     return pageCount;
73 | }


--------------------------------------------------------------------------------
/kernel/video/video.c:
--------------------------------------------------------------------------------
 1 | #include <video/video.h>
 2 | #include <string.h>
 3 | #include <time.h>
 4 | #include <stdio.h>
 5 | #include <tty/fbCon.h>
 6 | #include <memory/malloc.h>
 7 | 
 8 | uint32_t *image;
 9 | 
10 | void putPixel(int x, int y, uint32_t pixel) {
11 |    *((uint32_t*)(fbCon.ptr + 1 * (fbCon.pitch / 4) * y + 1 * x)) = pixel;
12 | }
13 | 
14 | uint32_t getPixel(uint32_t x, uint32_t y) {
15 |     return *((uint32_t*)(fbCon.ptr + 1 * (fbCon.pitch / 4) * y + 1 * x));
16 | }
17 | 
18 | void drawRect(int startx, int starty, int width, int height, uint32_t VGA_COLOR) {
19 |     int endx = startx + width;
20 |     int endy = starty + height;
21 | 
22 |     for (int x = startx; x < endx; x++) {
23 |         for (int y = starty; y < endy; y++) {
24 |             putPixel(x, y, VGA_COLOR);
25 |         }
26 |     }
27 | }
28 | 
29 | void drawImage(uint32_t *icon, int posx, int posy) {
30 |     int width = icon[0];
31 |     int height = icon[1];
32 |     for (int y = 0; y < height; y ++) {
33 |         for (int x = 0; x < width; x ++) {
34 |             putPixel(posx + x, posy + y, icon[y * width + x + 2]);
35 |         }
36 |     }
37 | }
38 | 
39 | uint32_t *getImage(int posx, int posy, int width, int height) {
40 |     int i = 2;
41 |     image[0] = width;
42 |     image[1] = height;
43 | 
44 |     for (int y = 0; y < height; y ++) {
45 |         for (int x = 0; x < width; x ++) {
46 |             image[i++] = getPixel(posx + x, posy + y);
47 |         }
48 |     }
49 |     return image;
50 | }
51 | 
52 | void Clear(uint32_t color) {
53 |     printf("%s", "\033[2J \033[H");
54 |     for (uint64_t x = 0; x < fbCon.width; x++) {
55 |         for (uint64_t y = 0; y < fbCon.height; y++) {
56 |             putPixel(x, y, 0);
57 |         }
58 |     }
59 | }
60 | 
61 | void setCursorPos(int x, int y) {
62 |     printf("\033[%i;%iH", x, y);
63 |     printf("%s", "\033[1;1H");
64 | }
65 | 
66 | void getCursorPos() {
67 |     printf("%s","\033[6n");
68 | }


--------------------------------------------------------------------------------
/include/string.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stdint.h>
 4 | #include <stdarg.h>
 5 | #include <stdbool.h>
 6 | #include <stddef.h>
 7 | 
 8 | typedef struct {
 9 |     char a[128];
10 |     char b[128];
11 | } TwoStrings;
12 | 
13 | /**
14 |  * @brief gets the length of the provided string
15 |  * 
16 |  * @param str the string to get the length of
17 |  * @return length of the string 
18 |  */
19 | extern size_t strlen(const char* str);
20 | 
21 | /**
22 |  * @brief turns the givin value into a string
23 |  * 
24 |  * @param value the value to turn into a string
25 |  * @return the uint64 givin in string form 
26 |  */
27 | const char *to_string(uint64_t value);
28 | 
29 | /**
30 |  * @brief turns the givin value into a hex string
31 |  * 
32 |  * @param value the value to turn into a hex string
33 |  * @return the uint64 givin in hex string form 
34 |  */
35 | const char *to_hstring(uint64_t value);
36 | 
37 | /**
38 |  * @brief checks to see if the given strings are the same
39 |  * 
40 |  * @param str1 
41 |  * @param str2 
42 |  * @return true or false depending if the strings are the same 
43 |  */
44 | extern int strcmp(char* str1, char* str2);
45 | 
46 | /**
47 |  * @brief splits the string at the specified character
48 |  * 
49 |  * @param str the string to split
50 |  * @param split the character to split them at
51 |  * @return the two strings in a TwoStrings struct 
52 |  */
53 | TwoStrings strsplit(char *str, char split);
54 | 
55 | extern size_t strnlen_s(const char* str, size_t strsz);
56 | 
57 | extern void *memset(void *b, int c, int len);
58 | extern void *memcpy(void* destination, const void* source, size_t num);
59 | extern int memcmp(const void *s1, const void *s2, int_fast64_t len);
60 | void *memmove(void *dest, const void *src, size_t n);
61 | 
62 | extern char   *strcat(char *restrict destination, const char *restrict source);
63 | 
64 | extern char *strstr(const char *haystack, const char *needle);
65 | extern char* strcpy(char* destination, const char* source);


--------------------------------------------------------------------------------
/kernel/init.c:
--------------------------------------------------------------------------------
 1 | #include <gdt/gdt.h>
 2 | #include <idt/idt.h>
 3 | #include <memory/mem.h>
 4 | #include <idt/interrupts.h>
 5 | #include <kernelDefines.h>
 6 | #include <init.h>
 7 | #include <tty/fbCon.h>
 8 | #include <stdio.h>
 9 | #include <memory/malloc.h>
10 | #include <tty.h>
11 | #include <acpi/acpi.h>
12 | #include <pci/pci.h>
13 | #include <bootloader.h>
14 | #include <userinput/mouse.h>
15 | 
16 | MODULE("INIT");
17 | 
18 | uint32_t defaultbg = 0x000000;
19 | uint32_t defaultfg = 0xffffff;
20 | extern uint32_t *image;
21 | extern uint32_t g_cursor_data[];
22 | 
23 | void init() {
24 |     TTY_SetWriteFunc(COM_LogWrapper);
25 |     BOOT_CheckLoader();
26 |     FBCON_Init();
27 |     for (uint64_t i = 0; i < mmap.response->entry_count; i++) {
28 |         uint64_t type = mmap.response->entries[i]->type;
29 |         if (type == LIMINE_MEMMAP_USABLE) {
30 |             MEM_Init((unsigned char*)mmap.response->entries[i]->base);
31 |         }
32 |     }
33 |     image = malloc((g_cursor_data[0] * g_cursor_data[1] * 4) + 8);
34 | 
35 |     initramfs = module.response->modules[0];
36 | 
37 |     GDTDescriptor gdtDescriptor;
38 |     gdtDescriptor.Size = sizeof(GDT) - 1;
39 |     gdtDescriptor.Offset = (uint64_t)&DefaultGDT;
40 |     LoadGDT(&gdtDescriptor);
41 | 
42 |     comout("TETS\n\r");
43 | 
44 |     create_idt();
45 |     InitPS2Mouse();
46 | 
47 | 
48 |     physical_kernel_start = kernel_address_request.response->physical_base;
49 | 	virtual_kernel_start = kernel_address_request.response->virtual_base;
50 | 
51 |     hhdm_offset = hhdm_request.response->offset;
52 |     
53 |     if (!initramfs) {
54 |         printf("[ %sINFO%s ] ramdisk not present\n", Blue, White);
55 |         panic("ERROR: no ramdisk found! how do you expect to be able to do anything without a disk?", NULL);
56 |     }
57 | 
58 |     log("root \"mounted\"", LOGLEVEL_INFO);
59 |     parse();
60 | 
61 |     ACPI_Init();
62 |     
63 |     EnumeratePCI(mcfg);
64 | 	log("PCI Enumerated", LOGLEVEL_INFO);
65 | }


--------------------------------------------------------------------------------
/include/stdio.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/stdio.h
 6 | ======================
 7 | */
 8 | 
 9 | #include <stdarg.h>
10 | #include <stdint.h>
11 | #include <stddef.h>
12 | 
13 | #ifdef __GNUC__
14 | #	if ((__GNUC__ == 4 && __GNUC_MINOR__>= 4) || __GNUC__ > 4)
15 | #		define ATTR_PRINTF(one_based_format_index, first_arg) __attribute__((format(gnu_printf, (one_based_format_index), (first_arg))))
16 | #	else
17 | #		define ATTR_PRINTF(one_based_format_index, first_arg) __attribute__((format(printf, (one_based_format_index), (first_arg))))
18 | #	endif
19 | #	define ATTR_VPRINTF(one_based_format_index) ATTR_PRINTF((one_based_format_index), 0)
20 | #else
21 | #	define ATTR_PRINTF(one_based_format_index, first_arg)
22 | #	define ATTR_VPRINTF(one_based_format_index)
23 | #endif
24 | extern int       puts(const char *string);
25 | extern int     printf(const char *format, ...)                                                              ATTR_PRINTF(1, 2);
26 | extern int    vprintf(const char *format, va_list arg)                                                      ATTR_VPRINTF(1);
27 | extern int    sprintf(char *s, const char *format, ...)                                                     ATTR_PRINTF(2, 3);
28 | extern int   vsprintf(char* s, const char* format, va_list arg)                                             ATTR_VPRINTF(2);
29 | extern int   snprintf(char* s, size_t count, const char* format, ...)                                       ATTR_PRINTF(3, 4);
30 | extern int  vsnprintf(char* s, size_t count, const char* format, va_list arg)                               ATTR_VPRINTF(3);
31 | extern int  fctprintf(void (*out)(char c, void* extraArg), void* extraArg, const char* format, ...)         ATTR_PRINTF(3, 4);
32 | extern int vfctprintf(void (*out)(char c, void* extraArg), void* extraArg, const char* format, va_list arg) ATTR_VPRINTF(3);
33 | 
34 | #undef ATTR_VPRINTF
35 | #undef ATTR_PRINTF
36 | 
37 | 
38 | extern void gPrint(const char chr[], unsigned int xOff, unsigned int yOff, uint32_t Color);
39 | extern void putchar(char c);


--------------------------------------------------------------------------------
/include/fs/ramfs.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <limine.h>
 4 | #include <kernel.h>
 5 | 
 6 | /*
 7 |  | offset |  size  | Description
 8 |  |   0    |   100  |  File name
 9 |  |   100  |   8    |  File mode
10 |  |   108  |   8    |  Owner's numeric user ID
11 |  |   116  |   8    |  Group's numeric user ID
12 |  |   124  |   12   |  File size in bytes (octal base)
13 |  |   136  |   12   |  Last modification time in numeric Unix time format (octal)
14 |  |   148  |   8    |  Checksum for header record
15 |  |   156  |   1    |  Type flag
16 |  |   157  |   100  |  Name of linked file
17 |  |   257  |   6    |  UStar indicator "ustar" then NUL
18 |  |   263  |   2    |  UStar version "00"
19 |  |   265  |   32   |  Owner user name
20 |  |   297  |   32   |  Owner group name
21 |  |   329  |   8    |  Device major number
22 |  |   337  |   8    |  Device minor number
23 |  |   345  |   155  |  Filename prefix
24 | */
25 | 
26 | /* Typeflag field definitions */
27 | #define REGTYPE 	'0'	/* Regular file. */
28 | #define LNKTYPE		'1'	/* Link. */
29 | #define SYMTYPE		'2'	/* Symbolic link. */
30 | #define CHRTYPE		'3'	/* Character special. */
31 | #define BLKTYPE		'4'	/* Block special. */
32 | #define DIRTYPE		'5'	/* Directory. */
33 | #define FIFOTYPE	'6'	/* FIFO special. */
34 | #define CONTTYPE	'7'	/* Reserved. */
35 | /* Mode field bit definitions (octal) */
36 | #define	TSUID		04000	/* Set UID on execution. */
37 | #define	TSGID		02000	/* Set GID on execution. */
38 | #define	TSVTX		01000	/* On directories, restricted deletion flag. */
39 | #define	TUREAD		00400	/* Read by owner. */
40 | #define	TUWRITE		00200	/* Write by owner. */
41 | #define	TUEXEC		00100	/* Execute/search by owner. */
42 | #define	TGREAD		00040	/* Read by group. */
43 | #define	TGWRITE		00020	/* Write by group. */
44 | #define	TGEXEC		00010	/* Execute/search by group. */
45 | #define	TOREAD		00004	/* Read by other. */
46 | #define	TOWRITE		00002	/* Write by other. */
47 | #define	TOEXEC		00001	/* Execute/search by other. */
48 | 
49 | struct tar_header
50 | {
51 |     char filename[100];
52 |     char mode[8];
53 |     char uid[8];
54 |     char gid[8];
55 |     char size[12];
56 |     char mtime[12];
57 |     char chksum[8];
58 |     char typeflag[1];
59 | };
60 | 
61 | 
62 | extern struct tar_header *headers[32];
63 | unsigned int parse();
64 | unsigned int getsize(const char *in);
65 | char *readFile(char* fileToReadName);
66 | void ls();


--------------------------------------------------------------------------------
/kernel/memory/malloc.c:
--------------------------------------------------------------------------------
 1 | #include <memory/malloc.h>	
 2 | #include <stddef.h>
 3 | #include <stdint.h>
 4 | #include <string.h>
 5 | #include <video/renderer.h>
 6 | #include <kernel.h>
 7 | 
 8 | typedef struct {
 9 |     bool free;
10 |     size_t size;
11 | } mem_control_blk;
12 |     
13 | void *aligned_ptr(char *ptr) {
14 |     while ((uintptr_t) ptr % sizeof(int) != 0) {
15 |         ptr++;
16 |     }
17 | 
18 |     return ptr;
19 | }
20 | 
21 | void *malloc(size_t size) {
22 |     if (!kernieHeap_is_set_up) {
23 |         last_valid_address = kernieHeap_space;
24 |         kernieHeap_is_set_up = true;
25 |     }
26 | 
27 |     unsigned char *current_ptr = kernieHeap_space;
28 |     char *allocated_location = 0;
29 | 
30 |     size += sizeof(mem_control_blk);
31 |     mem_control_blk *mcb = (mem_control_blk *)current_ptr;
32 | 
33 |     if (have_allocated) {
34 |         while (current_ptr != last_valid_address) {
35 |             if (mcb->free && mcb->size >= size) {
36 |                 mcb->free = false;
37 |                 allocated_location = (char*)current_ptr;
38 |                 break;
39 |             }
40 | 
41 |             current_ptr += mcb->size;
42 |             current_ptr = (unsigned char*)aligned_ptr((char*)current_ptr);
43 |             comout((const char*)current_ptr);
44 |         }
45 |     }
46 | 
47 |     if (!allocated_location) {
48 |         allocated_location = (char*)last_valid_address;
49 |         last_valid_address += size;
50 | 
51 |         mcb = (mem_control_blk*)allocated_location;
52 |         mcb->free = false;
53 |         mcb->size = size;
54 |     }
55 | 
56 |     allocated_location += sizeof(mem_control_blk);
57 | 
58 |     return allocated_location;
59 | }
60 | 
61 | void *realloc(char* ptr, size_t size) {
62 |     if (!ptr) {
63 |         return malloc(size);
64 |     }
65 | 
66 |     if (!size && ptr) {
67 |         free(ptr);
68 |         return NULL;
69 |     }
70 | 
71 |     void *new_ptr = malloc(size);
72 | 
73 |     mem_control_blk *mcb = (mem_control_blk *)(ptr - sizeof(mem_control_blk));
74 | 
75 |     memcpy(new_ptr, ptr, mcb->size);
76 |     free(ptr);
77 | 
78 |     return new_ptr;
79 | }
80 | 
81 | void free(void* ptr) {
82 |     if (!ptr) return;
83 | 
84 |     mem_control_blk *mcb = (mem_control_blk *)((char*)ptr - sizeof(mem_control_blk));
85 |     if (!mcb->size) return;
86 | 
87 |     mcb->free = true;
88 | }
89 | 
90 | void MEM_Init(unsigned char* addr) {
91 |     kernieHeap_space = addr;
92 | }


--------------------------------------------------------------------------------
/kernel/pci/pci.c:
--------------------------------------------------------------------------------
 1 | #include <pci/pci.h>
 2 | #include <disks/sata.h>
 3 | #include <acpi/acpi.h>
 4 | #include <stdio.h>
 5 | 
 6 | void EnumerateFunction(uint64_t deviceAddress, uint64_t function) {
 7 | 	uint64_t offset = function << 12;
 8 | 	uint64_t functionAddress = deviceAddress + offset;
 9 | 
10 | 	PCIDeviceHeader *pciDeviceHeader = (PCIDeviceHeader *)functionAddress;
11 | 
12 | 	if (pciDeviceHeader->DeviceID == 0)
13 | 		return;
14 | 
15 | 	if (pciDeviceHeader->DeviceID == 0xFFFF)
16 | 		return;
17 | 
18 | 	switch (pciDeviceHeader->Class) {
19 | 		case 0x01: { // mass storage controller
20 | 			switch (pciDeviceHeader->Subclass) {
21 | 				case 0x06: { // Serial ATA
22 | 					switch (pciDeviceHeader->ProgIF) {
23 | 						case 0x01: { // AHCI 1.0 device
24 | 							AHCIDriver_Init(pciDeviceHeader);
25 | 							//new AHCI::AHCIDriver(pciDeviceHeader);
26 | 							break;
27 | 						}
28 | 					}
29 | 				}
30 | 			}
31 | 		}
32 | 	}
33 | }
34 | 
35 | void EnumerateDevice(uint64_t busAddress, uint64_t device) {
36 | 	uint64_t offset = device << 15;
37 | 
38 | 	uint64_t deviceAddress = busAddress + offset;
39 | 
40 | 	PCIDeviceHeader *pciDeviceHeader = (PCIDeviceHeader *)deviceAddress;
41 | 
42 | 	if (pciDeviceHeader->DeviceID == 0) {
43 | 		return;
44 | 	}
45 | 	if (pciDeviceHeader->DeviceID == 0xFFFF) {
46 | 		return;
47 | 	}
48 | 
49 | 	for (uint64_t function = 0; function < 8; function++) {
50 | 		EnumerateFunction(deviceAddress, function);
51 | 	}
52 | }
53 | 
54 | void EnumerateBus(uint64_t baseAddress, uint64_t bus) {
55 | 	uint64_t offset = bus << 20;
56 | 
57 | 	uint64_t busAddress = baseAddress + offset;
58 | 
59 | 	PCIDeviceHeader *pciDeviceHeader = (PCIDeviceHeader *)busAddress;
60 | 
61 | 
62 | 	if (pciDeviceHeader->DeviceID == 0) {
63 | 		return;
64 | 	}
65 | 	if (pciDeviceHeader->DeviceID == 0xFFFF) {
66 | 		return;
67 | 	}
68 | 
69 | 	for (uint64_t device = 0; device < 32; device++) {
70 | 		EnumerateDevice(busAddress, device);
71 | 	}
72 | }
73 | 
74 | void EnumeratePCI(MCFGHeader *mcfg) {
75 | 
76 |     if(!mcfg) {
77 |         panic("MCFG was not found!", NULL);
78 |     }
79 | 
80 | 	int entries = ((mcfg->Header.length) - sizeof(MCFGHeader)) / sizeof(DeviceConfig);
81 | 	for (int t = 0; t < entries; t++) {
82 | 		DeviceConfig *newDeviceConfig = (DeviceConfig *)((uint64_t)mcfg + sizeof(MCFGHeader) + (sizeof(DeviceConfig) * t));
83 | 
84 | 		for (uint64_t bus = newDeviceConfig->StartBus; bus < newDeviceConfig->EndBus; bus++) {
85 | 			EnumerateBus(newDeviceConfig->BaseAddress, bus);
86 | 		}
87 | 	}
88 | }
89 | 


--------------------------------------------------------------------------------
/kernel/time.c:
--------------------------------------------------------------------------------
 1 | #include <time.h>
 2 | #include <io.h>
 3 | 
 4 | #define REG_SEC                         0x00
 5 | #define REG_SEC_ALARM                   0x01
 6 | #define REG_MIN                         0x02
 7 | #define REG_MIN_ALARM                   0x03
 8 | #define REG_HOUR                        0x04
 9 | #define REG_HOUR_ALARM                  0x05
10 | #define REG_WEEK_DAY                    0x06
11 | #define REG_DAY                         0x07
12 | #define REG_MONTH                       0x08
13 | #define REG_YEAR                        0x09
14 | #define REG_A                           0x0a
15 | #define REG_B                           0x0b
16 | #define REG_C                           0x0c
17 | #define REG_D                           0x0d
18 | 
19 | #define IO_RTC_INDEX                    0x70
20 | #define IO_RTC_TARGET                   0x71
21 | 
22 | #define REGB_DM                         (1 << 2)    // Data Mode (0 = BCD, 1 = Binary)
23 | 
24 | static uint8_t BcdToBin(uint8_t val)
25 | {
26 |     return (val & 0xf) + (val >> 4) * 10;
27 | }
28 | 
29 | static uint8_t RtcRead(uint8_t addr)
30 | {
31 |     outb(IO_RTC_INDEX, addr);
32 |     return inb(IO_RTC_TARGET);
33 | }
34 | 
35 | void sleep(uint8_t seconds)
36 | {
37 |     time oldtime = GetTime();
38 |     time CurrentTime = oldtime;
39 | 
40 |     while (CurrentTime.sec < oldtime.sec + seconds)
41 |     {
42 |         CurrentTime = GetTime();    
43 |     }
44 | }
45 | 
46 | time GetTime()
47 | {
48 |     uint8_t  sec = RtcRead(REG_SEC);
49 |     uint8_t  min = RtcRead(REG_MIN);
50 |     uint8_t  hour = RtcRead(REG_HOUR);
51 |     uint8_t  weekDay = RtcRead(REG_WEEK_DAY);
52 |     uint8_t  day = RtcRead(REG_DAY);
53 |     uint8_t  month = RtcRead(REG_MONTH);
54 |     uint16_t year = RtcRead(REG_YEAR);
55 | 
56 |     uint8_t regb = RtcRead(REG_B);
57 | 
58 |     if (~regb & REGB_DM)
59 |     {
60 |         sec = BcdToBin(sec);
61 |         min = BcdToBin(min);
62 |         hour = BcdToBin(hour);
63 |         day = BcdToBin(day);
64 |         month = BcdToBin(month);
65 |         year = BcdToBin(year);
66 |     }
67 |     // Century support
68 |     year += 2000;
69 | 
70 |     // Week day conversion: Sunday as the first day of the week (0-6)
71 |     weekDay--;
72 | 
73 |     time CurrentTime;
74 |     CurrentTime.weekDay = weekDay;
75 |     CurrentTime.day = day;
76 |     CurrentTime.month = month;
77 |     CurrentTime.year = year;
78 |     CurrentTime.hour = hour;
79 |     CurrentTime.min = min;
80 |     CurrentTime.sec = sec;
81 | 
82 |     return CurrentTime;
83 | }


--------------------------------------------------------------------------------
/kernel/idt/idt.c:
--------------------------------------------------------------------------------
 1 | #include <idt/idt.h>
 2 | #include <idt/interrupts.h>
 3 | #include <debugout.h>
 4 | #include <io.h>
 5 | 
 6 | void set_interrupt_offset(InterruptEntry* int_ptr, uint64_t offset) {
 7 | 	int_ptr->offset_0 = (uint16_t)((offset & 0x000000000000FFFF));
 8 | 	int_ptr->offset_1 = (uint16_t)((offset & 0x00000000FFFF0000) >> 16);
 9 | 	int_ptr->offset_2 = (uint32_t)((offset & 0xFFFFFFFF00000000) >> 32);
10 | }
11 | 
12 | uint64_t get_interrupt_offset(InterruptEntry* int_ptr) {
13 | 	uint64_t offset = 0;
14 | 
15 | 	offset |= (uint64_t)int_ptr->offset_0;
16 | 	offset |= (uint64_t)int_ptr->offset_1 << 16;
17 | 	offset |= (uint64_t)int_ptr->offset_2 << 32;
18 | 
19 | 	return offset;
20 | }
21 | 
22 | IDT idt;
23 | uint8_t idt_page[4096] = { 0 };
24 | 
25 | void CreateEntry(int interruptNum, uint64_t Handler) {
26 | 	InterruptEntry* entry = (InterruptEntry*)(idt.offset + interruptNum * sizeof(InterruptEntry));
27 | 	set_interrupt_offset(entry, Handler);
28 | 	entry->type_attribute = int_ta_gate;
29 | 	entry->selector = 0x08;
30 | }
31 | 
32 | void create_idt() {
33 | 	idt.limit = 0x0FFF;
34 | 	idt.offset = (uint64_t)&idt_page[0];
35 | 	
36 | 	CreateEntry(0xE,  (uint64_t)PageFault_Handler);
37 | 	CreateEntry(0x0,  (uint64_t)DivideByZero_Handler);
38 | 	CreateEntry(0x8,  (uint64_t)DoubleFault_Handler);
39 | 	CreateEntry(0xD,  (uint64_t)GPFault_Handler);
40 | 	CreateEntry(0x21, (uint64_t)Keyboard_Handler);
41 | 	CreateEntry(0x2C, (uint64_t)MouseInt_Handler);
42 | 	CreateEntry(0x69, (uint64_t)Test_Handler);
43 | 
44 | 	asm("lidt %0" : : "m" (idt));
45 | 	remap_interrupts_for_io();
46 | 	
47 | 	outb(mastr_pic_data_port, 0b11111001);
48 | 	outb(slave_pic_data_port, 0b11101111);
49 | 		
50 | 	asm("sti");
51 | }
52 | 
53 | 
54 | void remap_interrupts_for_io() {
55 | 	uint8_t mastr_data_value;
56 | 	uint8_t slave_data_value;
57 | 
58 | 	mastr_data_value = inb(mastr_pic_data_port); io_wait();
59 | 	slave_data_value = inb(slave_pic_data_port); io_wait();
60 | 
61 | 	outb(mastr_pic_cmnd_port, icw1_init | icw1_icw4); io_wait();
62 | 	outb(slave_pic_cmnd_port, icw1_init | icw1_icw4); io_wait();
63 | 
64 | 	outb(mastr_pic_data_port, 0x20); io_wait();
65 | 	outb(slave_pic_data_port, 0x28); io_wait();
66 | 
67 | 	outb(mastr_pic_data_port, 4); io_wait();
68 | 	outb(slave_pic_data_port, 2); io_wait();
69 | 
70 | 	outb(mastr_pic_data_port, icw4_8086); io_wait();
71 | 	outb(slave_pic_data_port, icw4_8086); io_wait();
72 | 
73 | 	outb(mastr_pic_data_port, mastr_data_value); io_wait();
74 | 	outb(slave_pic_data_port, slave_data_value); io_wait();
75 | }
76 | 
77 | void end_interrupts_for_mastr_io() {
78 | 	outb(mastr_pic_cmnd_port, pic_eoi);
79 | }
80 | 
81 | void end_interrupts_for_slave_io() {
82 | 	outb(slave_pic_cmnd_port, pic_eoi);
83 | 	end_interrupts_for_mastr_io();
84 | }


--------------------------------------------------------------------------------
/kernel/fs/ramfs.c:
--------------------------------------------------------------------------------
 1 | #include <fs/ramfs.h>
 2 | #include <string.h>
 3 | #include <stddef.h>
 4 | #include <stdio.h>
 5 | 
 6 | struct tar_header *headers[32];
 7 | 
 8 | unsigned int parse() {
 9 |     unsigned int address = *((int*)(&initramfs->address));
10 |     unsigned int i;
11 |  
12 |     for (i = 0; ; i++) {
13 |         struct tar_header *header = (struct tar_header *)address;
14 |         headers[i] = header;
15 | 
16 |         if (header->filename[0] == '\0')
17 |             break;
18 | 
19 |         unsigned int size = getsize(header->size);
20 |         address += ((size / 512) + 1) * 512;
21 |         
22 |         if (size % 512) {
23 |             address += 512;
24 |         }
25 |     }
26 |     return i;
27 | }
28 | 
29 | unsigned int getsize(const char *in) {
30 |     unsigned int size = 0;
31 |     unsigned int j;
32 |     unsigned int count = 1;
33 |  
34 |     for (j = 11; j > 0; j--, count *= 8) {
35 |         size += ((in[j - 1] - '0') * count);
36 |     }
37 |  
38 |     return size;
39 | }
40 | 
41 | char *readFile(char* fileToReadName) {
42 |     unsigned int address = *((int*)(&initramfs->address));
43 |     struct tar_header *header = (struct tar_header *)address;
44 | 
45 |     for (int i = 0; headers[i]->filename != "\0"; i++) {
46 |         if (strcmp(fileToReadName, headers[i]->filename)) {
47 |             header = headers[i];
48 |             break;
49 |         }
50 |     }
51 | 
52 |     char *contents = &((char *) header)[512]; // pointer shenanigans (:
53 | 
54 |     return contents;
55 | }
56 | 
57 | TwoStrings fullName;
58 | TwoStrings nameInPath;
59 | TwoStrings oldFullName;
60 | TwoStrings oldNameInPath;
61 | 
62 | void ls() {
63 |     for (int i = 1; headers[i]->filename[0] != 0; i++) {
64 |         for (int i = 0; i < 100; i++) fullName.a[i] =      '\0';
65 |         for (int i = 0; i < 100; i++) fullName.b[i] =      '\0';
66 |         for (int i = 0; i < 100; i++) nameInPath.a[i] =    '\0';
67 |         for (int i = 0; i < 100; i++) nameInPath.b[i] =    '\0';
68 |         for (int i = 0; i < 100; i++) oldFullName.a[i] =   '\0';
69 |         for (int i = 0; i < 100; i++) oldFullName.b[i] =   '\0';
70 |         for (int i = 0; i < 100; i++) oldNameInPath.a[i] = '\0';
71 |         for (int i = 0; i < 100; i++) oldNameInPath.b[i] = '\0';
72 | 
73 |         fullName   = strsplit(headers[i]->filename, '/');
74 |         nameInPath = strsplit(fullName.b, '/');
75 | 
76 |         if (i > 1) {
77 |             oldFullName   = strsplit(headers[i-1]->filename, '/');
78 |             oldNameInPath = strsplit(oldFullName.b, '/');    
79 |             if (strcmp(oldNameInPath.a, nameInPath.a) == 0) {
80 |                 printf("%s\n", nameInPath.a);
81 |             }
82 |         }
83 |         else {
84 |             printf("%s\n", nameInPath.a);
85 |         }
86 |     }
87 | }


--------------------------------------------------------------------------------
/include/forceInclude.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ======================
 3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
 4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
 5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/log.h
 6 | Another portion of this code is from https://github.com/techflashYT/Techflash-OS/blob/master/include/misc/defines.h
 7 | Another portion of this code is from https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/registers.h
 8 | ======================
 9 | */
10 | 
11 | 
12 | #include <stdint.h>
13 | // info that will almost never be useful except for when initially creating the code.
14 | #define LOGLEVEL_VERBOSE 0
15 | // info that could potentially be useful if having issues
16 | #define LOGLEVEL_DEBUG   1
17 | // info that could potentially be useful to an average user
18 | #define LOGLEVEL_INFO    2
19 | // something unexpected happened, this is a warning the user
20 | #define LOGLEVEL_WARN    3
21 | // something bad happened, we need to tell the user
22 | #define LOGLEVEL_ERROR   4
23 | // something EXTREMELY bad happened, this will usually be extended info just before a kernel panic.
24 | #define LOGLEVEL_FATAL   5
25 | extern void _log(const char module[8], const char *msg, const uint8_t level);
26 | 
27 | #define MODULE(x) static const char *MODNAME = (x)
28 | #define log(msg, level) _log(MODNAME, msg, level)
29 | 
30 | #define errorColor   0xFFFF4444
31 | #define warningColor 0xFFFFD866
32 | 
33 | #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
34 | 
35 | 
36 | #ifdef __x86_64__
37 | #include <arch/x86/registers.h>
38 | #endif
39 | 
40 | static inline void DUMPREGS(registers_t *regs) {
41 | 	asm ("mov %%rax,   %0" : "=r" (regs->rax));
42 | 	asm ("mov %%rbx,   %0" : "=r" (regs->rbx));
43 | 	asm ("mov %%rcx,   %0" : "=r" (regs->rcx));
44 | 	asm ("mov %%rdx,   %0" : "=r" (regs->rdx));
45 | 	asm ("mov %%rdi,   %0" : "=r" (regs->rdi));
46 | 	asm ("mov %%rsi,   %0" : "=r" (regs->rsi));
47 | 	asm ("mov %%rbp,   %0" : "=r" (regs->rbp));
48 | 	asm ("mov %%rsp,   %0" : "=r" (regs->rsp));
49 | 	asm ("mov %%r8,    %0" : "=r" (regs->r8));
50 | 	asm ("mov %%r9,    %0" : "=r" (regs->r9));
51 | 	asm ("mov %%r10,   %0" : "=r" (regs->r10));
52 | 	asm ("mov %%r11,   %0" : "=r" (regs->r11));
53 | 	asm ("mov %%r12,   %0" : "=r" (regs->r12));
54 | 	asm ("mov %%r13,   %0" : "=r" (regs->r13));
55 | 	asm ("mov %%r14,   %0" : "=r" (regs->r14));
56 | 	asm ("mov %%r15,   %0" : "=r" (regs->r15));
57 | 	asm ("mov %%cs,    %0" : "=r" (regs->cs));
58 | 	asm ("mov %%ss,    %0" : "=r" (regs->ss));
59 | 	asm ("sub $8, %%rsp; pushfq; popq %0; add $8, %%rsp" : "=r" (regs->rflags));
60 | 	asm ("lea (%%rip), %0" : "=r" (regs->rip));
61 | 	regs->intNo = 0x0;
62 | 	regs->errCode = 0x0;
63 | }


--------------------------------------------------------------------------------
/tools/icontest:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python3
  2 | import sys
  3 | import numpy as np
  4 | from misc import *
  5 | import cv2
  6 | 
  7 | if len(sys.argv) < 3:
  8 |     print("Usage: iconconv <bitmapfile> <output_name>")
  9 |     raise TypeError("Usage: iconconv <bitmapfile> <output_name>")
 10 | 
 11 | bmp = sys.argv[1]
 12 | output = sys.argv[2]
 13 | outputFile = sys.argv[2]
 14 | 
 15 | modTime = os.path.getmtime(bmp)
 16 | modDate = time.ctime(modTime)
 17 | 
 18 | image = cv2.imread(bmp, cv2.IMREAD_UNCHANGED)
 19 | 
 20 | tmp = output.split("/")
 21 | array = tmp[-1].split(".")
 22 | 
 23 | newPicture = array[0]
 24 | print(newPicture)
 25 | 
 26 | width = image.shape[1]
 27 | height = image.shape[0]
 28 | channel = image.shape[2]
 29 | 
 30 | test = modDate.split(" ")
 31 | 
 32 | newMonth = test[1]
 33 | newDay   = test[2]
 34 | newYear  = test[4]
 35 | 
 36 | FinalModDate = ["", "", ""]
 37 | 
 38 | FinalModDate[0] = newMonth
 39 | FinalModDate[1] = newDay
 40 | FinalModDate[2] = newYear
 41 | 
 42 | FinalFinalModDate = "/".join(FinalModDate)
 43 | split = output.split(".")
 44 | 
 45 | 
 46 | #print("picture:", bmp,end="")
 47 | #print(", output:", output,end="")
 48 | #print(", outputFile:", outputFile)
 49 | 
 50 | print(tmp)
 51 | 
 52 | if output[-1] != "h":
 53 |     raise TypeError("OUTPUT FILE IS NOT A .h FILE!")
 54 | 
 55 | f = open(output, "wt")
 56 | f.write("/*****************************************  \n")
 57 | f.write("                   SeshOS                   \n")
 58 | f.write("                                          \n\n")
 59 | f.write("  This is a converted icon to embed into    \n")
 60 | f.write("            the kernel image.               \n")
 61 | f.write(" * Converted File: ")
 62 | f.write(bmp)
 63 | f.write("                                            \n")
 64 | f.write(" * Converted Date: ")
 65 | f.write(str(newToday))
 66 | f.write("                                            \n")
 67 | f.write(" * Icon Last Mod: ")
 68 | f.write(str(FinalFinalModDate))
 69 | f.write("                                            \n")
 70 | f.write("*****************************************/\n\n")
 71 | 
 72 | f.close()
 73 | 
 74 | x = 0
 75 | y = 0
 76 | 
 77 | f = open(output, "at")
 78 | 
 79 | f.write("uint32_t g_")
 80 | f.write(newPicture)
 81 | f.write("_data[] = {\n\t")
 82 | f.write(f"{width}, {height}, ")
 83 | 
 84 | for y in range(height):
 85 |     for x in range(width):
 86 | 
 87 |         pixel = image[y, x]
 88 |         rgba = 0
 89 | 
 90 |         rgba |= (pixel[0] << 0)    #blue
 91 |         rgba |= (pixel[1] << 8)    #green
 92 |         rgba |= (pixel[2] << 16)   #red
 93 | 
 94 |         hexWithout0x = str(hex(rgba)).split("x")
 95 | 
 96 |         toAdd = ["0x00", "", ", "]
 97 |         toAdd[1] = hexWithout0x[1] 
 98 | 
 99 |         newHex = "".join(toAdd)
100 | 
101 |         #if(pixel[2] == 0):
102 |         #    newHex = "0xffffffff, "
103 | 
104 |         if(newHex == "0x000, "):
105 |             newHex = "0x00000000, "
106 |         f.write(newHex)
107 |     f.write("\n")
108 | 
109 | f.write("};\n\n")
110 | 
111 | f.close()


--------------------------------------------------------------------------------
/kernel/userinput/keyboard.c:
--------------------------------------------------------------------------------
  1 | #include <userinput/keyboard.h>
  2 | #include <video/renderer.h>
  3 | #include <stdio.h>
  4 | 
  5 | bool isLeftShiftPressed;
  6 | bool isRightShiftPressed;
  7 | 
  8 | 
  9 | char input[100];
 10 | int i = 0;
 11 | 
 12 | void HandleKeyboard(uint8_t scancode) {
 13 | 	char c = get_us_qwerty_char_from_scan_code(scancode);
 14 | 
 15 | 	if (scancode == us_qwerty_left_shift) {
 16 | 		is_us_qwerty_left_shift_pressed = 1;
 17 | 		c = '\0';
 18 | 	}
 19 | 	else if (scancode == us_qwerty_right_shift) {
 20 | 		is_us_qwerty_right_shift_pressed = 1;
 21 | 		c = '\0';
 22 | 	}
 23 | 
 24 | 	if (scancode == us_qwerty_left_shift + 0x80) {
 25 | 		is_us_qwerty_left_shift_pressed = 0;
 26 | 		c = '\0';
 27 | 	}
 28 | 	else if (scancode == us_qwerty_right_shift + 0x80) {
 29 | 		is_us_qwerty_right_shift_pressed = 0;
 30 | 		c = '\0';
 31 | 	}
 32 | 
 33 | 	if (scancode == us_qwerty_enter){
 34 | 		printf("\n");
 35 | 		c = '\0';
 36 | 		i = 0;
 37 | 		
 38 | 		for (int i = 0; i < 100; i ++) {
 39 | 		    input[i] = '\0';
 40 | 		}
 41 | 	}
 42 | 	else if (scancode == us_qwerty_backspace) {
 43 | 		putchar('\b');
 44 | 		c = '\0';
 45 | 		i--;
 46 | 		input[i] = '\0';
 47 | 		if (i < 0) {
 48 | 			i = 0;
 49 | 		}
 50 | 	}
 51 | 
 52 | 	if (c != '\0') {
 53 | 		char str[2] = {c, '\0'};
 54 | 		input[i] = c;
 55 | 		i++;
 56 | 		printf(str);
 57 | 	}
 58 | 
 59 | 	uint16_t port = 0x20;
 60 | 	uint8_t value = 0x20;
 61 | 
 62 |     asm volatile("outb %0, %1" :: "a"(value), "Nd"(port));
 63 | }
 64 | 
 65 | uint8_t is_us_qwerty_left_shift_pressed;
 66 | uint8_t is_us_qwerty_right_shift_pressed;
 67 | 
 68 | char us_qwerty_ascii_ps2_mapping[] = {
 69 | 	'\0', '\0', '1', '2', '3', '4', '5', '6', '7', '8', 
 70 | 	'9', '0', '-', '=', '\0', '\0', 'q', 'w', 'e', 'r', 
 71 | 	't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\0', '\0', 
 72 | 	'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', 
 73 | 	'\'', '`', '\0', '\\', 'z', 'x', 'c', 'v', 'b', 'n', 
 74 | 	'm', ',', '.', '/', '\0', '*', '\0', ' '
 75 | };
 76 | 
 77 | char get_us_qwerty_char_from_scan_code(uint8_t scancode) {
 78 | 	if (scancode > 58) return '\0';
 79 | 	
 80 | 	char c = us_qwerty_ascii_ps2_mapping[scancode];
 81 | 	
 82 | 	if ((is_us_qwerty_left_shift_pressed || is_us_qwerty_right_shift_pressed)) {
 83 | 		// letters
 84 | 		if (c > 96 && c < 123) c -= 32;
 85 | 		
 86 | 		// numbers
 87 | 		if		(c == '1')	c = '!';
 88 | 		else if (c == '2')	c = '@';
 89 | 		else if (c == '3')	c = '#';
 90 | 		else if (c == '4')	c = '$';
 91 | 		else if (c == '5')	c = '%';
 92 | 		else if (c == '6')	c = '^';
 93 | 		else if (c == '7')	c = '&';
 94 | 		else if (c == '8')	c = '*';
 95 | 		else if (c == '9')	c = '(';
 96 | 		else if (c == '0')	c = ')';
 97 | 		
 98 | 		// misc
 99 | 		if		(c == '`' )	c = '~';
100 | 		else if (c == '-' )	c = '_';
101 | 		else if (c == '=' )	c = '+';
102 | 		else if (c == '[' )	c = '{';
103 | 		else if (c == ']' )	c = '}';
104 | 		else if (c == '\\')	c = '|';
105 | 		else if (c == ';' )	c = ':';
106 | 		else if (c == '\'')	c = '"';
107 | 		else if (c == ',' )	c = '<';
108 | 		else if (c == '.' )	c = '>';
109 | 		else if (c == '/' )	c = '?';
110 | 	}
111 | 	
112 | 	return c;
113 | }


--------------------------------------------------------------------------------
/include/userinput/cursor.h:
--------------------------------------------------------------------------------
 1 | /*****************************************  
 2 |                    SeshOS                   
 3 |                                           
 4 | 
 5 |   This is a converted icon to embed into    
 6 |             the kernel image.               
 7 |  * Converted File: cursor.png                                            
 8 |  * Converted Date: 06/21/2024                                            
 9 |  * Icon Last Mod: Jun/21/2024                                            
10 | *****************************************/
11 | 
12 | uint32_t g_cursor_data[] = {
13 | 	12, 19, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
14 |             0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
15 |             0x000000, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
16 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
17 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
18 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
19 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
20 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
21 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 
22 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 
23 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 
24 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 
25 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
26 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
27 |             0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 
28 |             0x000000, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 
29 |             0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 
30 |             0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 
31 |             0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 
32 | };
33 | 
34 | 


--------------------------------------------------------------------------------
/kernel/acpi/acpi.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ======================
  3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
  4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
  5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/old/kernel/acpi.c
  6 | ======================
  7 | */
  8 | #include <stdio.h>
  9 | #include <string.h>
 10 | #include <acpi/acpi.h>
 11 | #include <kernel.h>
 12 | #include <stdbool.h>
 13 | 
 14 | MODULE("X86ACPI");
 15 | 
 16 | MCFGHeader* mcfg;
 17 | 
 18 | volatile struct limine_rsdp_request rsdpReq = {
 19 | 	.id = LIMINE_RSDP_REQUEST,
 20 | 	.revision = 0
 21 | };
 22 | static bool doChecksum(ACPISDTHeader *tableHeader) {
 23 | 	uint_fast32_t sum = 0;
 24 | 
 25 | 	for (uint32_t i = 0; i < tableHeader->length; i++) {
 26 | 		sum += ((char *)tableHeader)[i];
 27 | 	}
 28 | 	if (sum != 0) {
 29 | 		char str[64];
 30 | 		#if UINT_FAST32_MAX == UINT32_MAX
 31 | 		sprintf(str, "Checksum wrong by %u", sum);
 32 | 		#elif UINT_FAST32_MAX == UINT64_MAX
 33 | 		sprintf(str, "Checksum wrong by %lu", sum);
 34 | 		#else
 35 | 		#error Unsupported uint_fast32_t size
 36 | 		#endif
 37 | 		log(str, LOGLEVEL_WARN);
 38 | 	}
 39 | 	return sum == 0;
 40 | }
 41 | 
 42 | void ACPI_Init() {
 43 | 	uint8_t *p = rsdpReq.response->address;
 44 | 	if (memcmp(p, "RSD PTR ", 8) != 0) {
 45 | 		log("Bad ACPI", LOGLEVEL_FATAL);
 46 | 		return;
 47 | 	}
 48 | 	char str[64];
 49 | 	sprintf(str, "Found ACPI Tables at address %p!", p);
 50 | 	log(str, LOGLEVEL_INFO);
 51 | 
 52 | 	RSDPDescriptor20 *rsdp = (RSDPDescriptor20 *)p;
 53 | 	uint8_t rev = rsdp->firstPart.revision;
 54 | 
 55 | 	if (rev == 0) {
 56 | 		log("ACPI Revision 1.0", LOGLEVEL_INFO);
 57 | 	}
 58 | 	else {
 59 | 		log("ACPI Revision >= 2.0", LOGLEVEL_INFO);
 60 | 	}
 61 | 	char OEMID[7] = {0};
 62 | 	memcpy(OEMID, rsdp->firstPart.OEMId, 6);
 63 | 
 64 | 	sprintf(str, "OEM ID: %s", OEMID);
 65 | 	log(str, LOGLEVEL_INFO);
 66 | 
 67 | 
 68 | 	RSDT *rsdt = (RSDT *)(uint64_t)rsdp->firstPart.RSDTAddress;
 69 | 	char sig[5] = {0};
 70 | 	memcpy(sig, rsdt->h.signature, 4);
 71 | 
 72 | 	if (memcmp(rsdt->h.signature, "RSDT", 4) != 0) {
 73 | 		registers_t regs;
 74 | 		DUMPREGS(&regs);
 75 | 		sprintf(str, "ACPI RSDT signature not correct!  Expected: \"RSDT\", got: \"%-4s\"", sig);
 76 | 		log(str, LOGLEVEL_FATAL);
 77 | 		panic("ACPI RSDT Signature invalid", &regs);
 78 | 	}
 79 | 
 80 | 	sprintf(str, "Found ACPI RSDT.  Signature: \"%-4s\"", sig);
 81 | 	log (str, LOGLEVEL_INFO);
 82 | 	if (doChecksum(&rsdt->h)) {
 83 | 		log("ACPI RSDT Checksum passed.", LOGLEVEL_INFO);
 84 | 	}
 85 | 
 86 | 	memcpy(OEMID, rsdt->h.OEMId, 6);
 87 | 	sprintf(str, "RSDT OEM ID: %s", OEMID);
 88 | 	log(str, LOGLEVEL_INFO);
 89 | 
 90 | 	uint32_t OEMRev = rsdt->h.OEMRevision;
 91 | 	sprintf(str, "RSDT OEM Revision: %u", OEMRev);
 92 | 	log(str, LOGLEVEL_INFO);
 93 | 
 94 | 	
 95 | 	int entries = (rsdt->h.length - sizeof(rsdt->h)) / 4;
 96 | 
 97 | 	for (int i = 0; i < entries; i++) {
 98 | 		ACPISDTHeader *h = (ACPISDTHeader *)(uint64_t)rsdt->pointerToOtherSDT[i];
 99 | 		char str[64];
100 | 
101 | 		memcpy(sig, h->signature, 4);
102 | 		sprintf(str, "Found ACPI Entry: \"%-4s\"", sig);
103 | 		log(str, LOGLEVEL_INFO);
104 | 		if (memcmp(h->signature, "FACP", 4) == 0) {
105 | 			// TODO: Handle FACP
106 | 			log("Found FACP", LOGLEVEL_INFO);
107 | 		}
108 | 		if (memcmp(h->signature, "MCFG", 4) == 0) {
109 | 			mcfg = (MCFGHeader*)h;
110 | 		}
111 | 	}
112 | }


--------------------------------------------------------------------------------
/include/disks/sata.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <stdint.h>
  4 | #include <pci/pci.h>
  5 | 
  6 | typedef enum {
  7 |     None = 0,
  8 |     SATA = 1,
  9 |     SEMB = 2,
 10 |     PM = 3,
 11 |     SATAPI = 4
 12 | } PortType;
 13 | 
 14 | typedef enum {
 15 |     FIS_TYPE_REG_H2D = 0x27,
 16 |     FIS_TYPE_REG_D2H = 0x34,
 17 |     FIS_TYPE_DMA_ACT = 0x39,
 18 |     FIS_TYPE_DMA_SETUP = 0x41,
 19 |     FIS_TYPE_DATA = 0x46,
 20 |     FIS_TYPE_BIST = 0x58,
 21 |     FIS_TYPE_PIO_SETUP = 0x5F,
 22 |     FIS_TYPE_DEV_BITS = 0xA1
 23 | } FIS_TYPE;
 24 | 
 25 | typedef struct {
 26 |     uint32_t commandListBase;
 27 |     uint32_t commandListBaseUpper;
 28 |     uint32_t fisBaseAddress;
 29 |     uint32_t fisBaseAddressUpper;
 30 |     uint32_t interruptStatus;
 31 |     uint32_t interruptEnable;
 32 |     uint32_t cmdSts;
 33 |     uint32_t rsv0;
 34 |     uint32_t taskFileData;
 35 |     uint32_t signature;
 36 |     uint32_t sataStatus;
 37 |     uint32_t sataControl;
 38 |     uint32_t sataError;
 39 |     uint32_t sataActive;
 40 |     uint32_t commandIssue;
 41 |     uint32_t sataNotification;
 42 |     uint32_t fisSwitchControl;
 43 |     uint32_t rsv1[11];
 44 |     uint32_t vendor[4];
 45 | } HBAPort;
 46 | 
 47 | typedef struct {
 48 |     uint32_t hostCapability;
 49 |     uint32_t globalHostControl;
 50 |     uint32_t interruptStatus;
 51 |     uint32_t portsImplemented;
 52 |     uint32_t version;
 53 |     uint32_t cccControl;
 54 |     uint32_t cccPorts;
 55 |     uint32_t enclosureManagementLocation;
 56 |     uint32_t enclosureManagementControl;
 57 |     uint32_t hostCapabilitiesExtended;
 58 |     uint32_t biosHandoffCtrlSts;
 59 |     uint8_t rsv0[0x74];
 60 |     uint8_t vendor[0x60];
 61 |     HBAPort ports[1];
 62 | } HBAMemory;
 63 | 
 64 | typedef struct {
 65 |     uint8_t commandFISLength:5;
 66 |     uint8_t atapi:1;
 67 |     uint8_t write:1;
 68 |     uint8_t prefetchable:1;
 69 |     uint8_t reset:1;
 70 |     uint8_t bist:1;
 71 |     uint8_t clearBusy:1;
 72 |     uint8_t rsv0:1;
 73 |     uint8_t portMultiplier:4;
 74 |     uint16_t prdtLength;
 75 |     uint32_t prdbCount;
 76 |     uint32_t commandTableBaseAddress;
 77 |     uint32_t commandTableBaseAddressUpper;
 78 |     uint32_t rsv1[4];
 79 | } HBACommandHeader;
 80 | 
 81 | typedef struct {
 82 |     uint32_t dataBaseAddress;
 83 |     uint32_t dataBaseAddressUpper;
 84 |     uint32_t rsv0;
 85 |     uint32_t byteCount:22;
 86 |     uint32_t rsv1:9;
 87 |     uint32_t interruptOnCompletion:1;
 88 | } HBAPRDTEntry;
 89 | 
 90 | typedef struct {
 91 |     uint8_t commandFIS[64];
 92 |     uint8_t atapiCommand[16];
 93 |     uint8_t rsv[48];
 94 |     HBAPRDTEntry prdtEntry[];
 95 | } HBACommandTable;
 96 | 
 97 | typedef struct {
 98 |     uint8_t fisType;
 99 |     uint8_t portMultiplier:4;
100 |     uint8_t rsv0:3;
101 |     uint8_t commandControl:1;
102 |     uint8_t command;
103 |     uint8_t featureLow;
104 |     uint8_t lba0;
105 |     uint8_t lba1;
106 |     uint8_t lba2;
107 |     uint8_t deviceRegister;
108 |     uint8_t lba3;
109 |     uint8_t lba4;
110 |     uint8_t lba5;
111 |     uint8_t featureHigh;
112 |     uint8_t countLow;
113 |     uint8_t countHigh;
114 |     uint8_t isoCommandCompletion;
115 |     uint8_t control;
116 |     uint8_t rsv1[4];
117 | } FIS_REG_H2D;
118 | 
119 | typedef struct {
120 |     HBAPort* hbaPort;
121 |     PortType portType;
122 |     uint8_t* buffer;
123 |     uint8_t portNumber;
124 | } Port;
125 | 
126 | typedef struct {
127 |     PCIDeviceHeader* PCIBaseAddress;
128 |     HBAMemory* ABAR;
129 |     Port* ports[32];
130 |     uint8_t portCount;
131 | } AHCIDriver;
132 | 
133 | void Configure(Port* port);
134 | void StartCMD(Port* port);
135 | void StopCMD(Port* port);
136 | int Read(Port* port, uint64_t sector, uint32_t sectorCount, void* buffer);
137 | 
138 | AHCIDriver* AHCIDriver_Init(PCIDeviceHeader* pciBaseAddress);
139 | void AHCIDriver_Destroy(AHCIDriver* driver);
140 | void AHCIDriver_ProbePorts(AHCIDriver* driver);


--------------------------------------------------------------------------------
/kernel/video/fbcon.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ======================
  3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
  4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
  5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/include/kernel/tty.h
  6 | ======================
  7 | */
  8 | 
  9 | #include <tty/fbCon.h>
 10 | #include <tty.h>
 11 | #include <bootloader.h>
 12 | #include <stddef.h>
 13 | #include <stdbool.h>
 14 | #include <string.h>
 15 | #include <video/video.h>
 16 | #include <userinput/cursor.h>
 17 | 
 18 | extern uint32_t *image;
 19 | 
 20 | framebuffer_t fbCon;
 21 | uint32_t MouseCursorBuffer[16 * 16];
 22 | uint32_t MouseCursorBufferAfter[16 * 16];
 23 | bool MouseDrawn;
 24 | 
 25 | MODULE("FBCON");
 26 | extern framebuffer_t LM_GetFramebuffer();
 27 | 
 28 | static bool esc = false;
 29 | 
 30 | 
 31 | static void FBCON_ScrollMaybe() {
 32 | 	if (TTY_CursorX >= TTY_Width) {
 33 | 		TTY_CursorX = 0;
 34 | 		TTY_CursorY++;
 35 | 	}
 36 | 	if (TTY_CursorY > TTY_Height) {
 37 | 		size_t fontSz = ((fbCon.width * 4) * 16);
 38 | 		uint8_t *srcAddr = (((uint8_t *)fbCon.ptr) + fontSz);
 39 | 		size_t size = (fbCon.width * 4) * fbCon.height;
 40 | 		memmove(fbCon.ptr, srcAddr, size);
 41 | 		TTY_CursorY--;
 42 | 
 43 | 		uint8_t *startZeroAddr = (srcAddr + size) - fontSz;
 44 | 		memset(startZeroAddr, 0, fontSz);
 45 | 		// TTY_CursorX = 0;
 46 | 	}
 47 | }
 48 | void FBCON_Write(const char ch, const uint16_t x, const uint16_t y, const uint32_t fgColor, const uint32_t bgColor) {
 49 | 	if (ch == '\x1b') {
 50 | 		esc = true;
 51 | 		return;
 52 | 	}
 53 | 	if (esc) {
 54 | 		esc = !TTY_HandleEsc(ch);
 55 | 		return;
 56 | 	}
 57 | 	switch (ch) {
 58 | 		case '\r': {
 59 | 			TTY_CursorX = 0;
 60 | 			return;
 61 | 		}
 62 | 		case '\n': {
 63 | 			TTY_CursorY++;
 64 | 			FBCON_ScrollMaybe();
 65 | 			return;
 66 | 		}
 67 | 		case '\t': {
 68 | 			TTY_CursorX += 4;
 69 | 			return;
 70 | 		}
 71 | 	}
 72 | 	uint8_t *charData = font[(uint8_t)ch];
 73 | 	uint32_t offset = ((y * 16) * fbCon.width) + (x * 8);
 74 | 	for (uint_fast8_t i = 0; i != 16; i++) {
 75 | 		for (uint_fast8_t j = 7; j != 0; j--) {
 76 | 			uint32_t color = bgColor;
 77 | 			if (charData[i] & (1 << j)) {
 78 | 				color = fgColor;
 79 | 				if (TTY_Bold) {
 80 | 					// FIXME: for VGA yellow, we need to add 0xAA to the green for some reason
 81 | 					if (color == COLOR_YELLOW) {
 82 | 						color = 0xFFFF55;
 83 | 						goto done;
 84 | 					}
 85 | 					// increase the brightness of the color by incresing all but the first byte of the uint32_t value
 86 | 					for (uint_fast8_t k = 0; k != 4; k++) {
 87 | 						uint8_t originalByte = ((uint8_t*)&color)[k];
 88 | 						((uint8_t *)&color)[k] += 0x55;
 89 | 
 90 | 						// Check for overflow
 91 | 						if (((uint8_t *)&color)[k] < originalByte) {
 92 | 							((uint8_t *)&color)[k] = 0xFF;
 93 | 						}
 94 | 					}
 95 | 				}
 96 | 			}
 97 | 			done:
 98 | 			fbCon.ptr[offset + (7 - j) + (i * fbCon.width)] = color;
 99 | 		}
100 | 	}
101 | 	
102 | 	TTY_CursorX++;
103 | 	FBCON_ScrollMaybe();
104 | }
105 | 
106 | static bool firstRun = true;
107 | 
108 | static void FBCON_InitSimple() {
109 | 	if (BOOT_LoaderID == BOOT_LoaderID_LimineCompatible) {
110 | 		fbCon = LM_GetFramebuffer();
111 | 	}
112 | 	else {
113 | 		log("Unknown bootloader.  Unable to set framebuffer!  Keeping print method to default, you will probably not have video output!", LOGLEVEL_FATAL);
114 | 		fbCon = (framebuffer_t){.ptr = NULL, .width = 0, .height = 0, .mode = 0};
115 | 	}
116 | 
117 | 	TTY_CursorX  = 0;
118 | 	TTY_CursorY  = 0;
119 | 	TTY_Width    = (uint16_t)(fbCon.width  / 8);
120 | 	TTY_Height   = (uint16_t)(fbCon.height / 16);
121 | 	TTY_Color    = COLOR_LGRAY;
122 | 	TTY_Bold     = false;
123 | 
124 | 	if (fbCon.ptr != 0) {
125 | 		log("Setting TTY Write func", LOGLEVEL_DEBUG);
126 | 		TTY_SetWriteFunc(FBCON_Write);
127 | 		log("Done setting TTY Write func", LOGLEVEL_DEBUG);
128 | 	}
129 | }
130 | 
131 | static void FBCON_InitReal() {
132 | 	log("Not implemented I guess", LOGLEVEL_FATAL);
133 | }
134 | 
135 | void FBCON_Init() {
136 | 	if (firstRun) {
137 | 		FBCON_InitSimple();
138 | 		firstRun = false;
139 | 		return;
140 | 	}
141 | 	FBCON_InitReal();
142 | 	return;
143 | }
144 | 
145 | void ClearMouseCursor(point_t position)
146 | {
147 |     drawImage(image, position.X, position.Y);
148 | }
149 | 
150 | void DrawOverlayMouseCursor(point_t position)
151 | {
152 | 	image = getImage(position.X, position.Y, image[0], image[1]);
153 | 	drawImage(g_cursor_data, position.X, position.Y);
154 | }


--------------------------------------------------------------------------------
/kernel/string.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ======================
  3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
  4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
  5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/libc/string/
  6 | ======================
  7 | */
  8 | #include <limine.h>
  9 | #include <string.h>
 10 | #include <video/video.h>
 11 | #include <stdint.h>
 12 | #include <stddef.h>
 13 | #include <assert.h>
 14 | 
 15 | char hexTo_StringOutput[128];
 16 | const char *to_hstring(uint64_t value) {
 17 |     uint64_t *valPtr = &value;
 18 |     uint8_t *ptr;
 19 |     uint8_t tmp;
 20 |     uint8_t size = 8 * 2 - 1;
 21 |     for (uint8_t i = 0; i < size; i++) {
 22 |         ptr = ((uint8_t *)valPtr + i);
 23 |         tmp = ((*ptr & 0xF0) >> 4);
 24 |         hexTo_StringOutput[size - (i * 2 + 1)] = tmp + (tmp > 9 ? 55 : '0');
 25 |         tmp = ((*ptr & 0x0F));
 26 |         hexTo_StringOutput[size - (i * 2)] = tmp + (tmp > 9 ? 55 : '0');
 27 |     }
 28 |     hexTo_StringOutput[size + 1] = 0;
 29 |     return hexTo_StringOutput;
 30 | }
 31 | 
 32 | size_t strlen(const char* str) {
 33 |     unsigned int i = 0;
 34 |     for (; str[i] != '\0'; i++);
 35 |     return i;
 36 | }
 37 | 
 38 | int strcmp(char *str1, char *str2) {
 39 | 	while (*str1) {
 40 | 		// if characters differ, or end of the second string is reached
 41 | 		if (*str1 != *str2) {
 42 | 			break;
 43 | 		}
 44 |  
 45 | 		// move to the next pair of characters
 46 | 		str1++;
 47 | 		str2++;
 48 | 	}
 49 |  
 50 | 	// return the ASCII difference after converting `char*` to `unsigned char*`
 51 | 	return *(const uint8_t *)str1 - *(const uint8_t *)str2;
 52 | }
 53 | size_t strnlen_s(const char* str, size_t strsz) {
 54 | 	const char* s;
 55 | 	for (s = str; *s && strsz--; ++s);
 56 | 	return (s - str);
 57 | }
 58 | 
 59 | 
 60 | TwoStrings strsplit(char *str, char split) {
 61 |     char p1[128];
 62 |     char p2[128];
 63 |     unsigned int i = 0;
 64 |     unsigned int j = 0;
 65 |     
 66 |     for (; i < strlen(str) && str[i] != split; i++) {
 67 |         p1[i] = str[i];
 68 |     }
 69 |     i++;
 70 |     p1[i - 1] = '\0';
 71 |     for (; i < strlen(str); j++) {
 72 |         p2[j] = str[i];
 73 |         i++;
 74 |     }
 75 |     j++;
 76 |     p2[j - 1] = '\0';
 77 |     TwoStrings yes;
 78 | 
 79 |     for (int i = 0; i < 128; i++) {
 80 |         yes.a[i] = p1[i];
 81 |         yes.b[i] = p2[i];
 82 |     }
 83 |     
 84 |     return yes;
 85 | }
 86 | 
 87 | int isdigit(int ch) {
 88 | 	return (ch >= '0') && (ch <= '9');
 89 | }
 90 | 
 91 | #include <string.h>
 92 | char *strcat(char* restrict destination, const char* restrict source) {
 93 | 	// ptr to end of dest
 94 | 	char *ptr = destination + strlen(destination);
 95 | 	
 96 | 	// append to dest
 97 | 	while (*source != '\0') {
 98 | 		*ptr++ = *source++;
 99 | 	}
100 | 
101 | 	// null terminate
102 | 	*ptr = '\0';
103 | 
104 | 	// return dest
105 | 	return destination;
106 | }
107 | 
108 | 
109 | char *strstr(const char *haystack, const char *needle) {
110 | 	size_t size = strlen(needle);
111 | 
112 | 	while (*haystack) {
113 | 		if (!memcmp(haystack, needle, size)) {
114 | 			return (char *)haystack;
115 | 		}
116 | 		haystack++;
117 | 	}
118 | 	return NULL;
119 | }
120 | 
121 | 
122 | char* strcpy(char* destination, const char* source) {
123 | 	// return if no memory is allocated to the destination
124 | 	if (destination == NULL) {
125 | 		return NULL;
126 | 	}
127 |  
128 | 	// take a pointer pointing to the beginning of the destination string
129 | 	char *ptr = destination;
130 |  
131 | 	// copy the C-string pointed by source into the array
132 | 	// pointed by destination
133 | 	while (*source != '\0') {
134 | 		*destination = *source;
135 | 		destination++;
136 | 		source++;
137 | 	}
138 |  
139 | 	// include the terminating null character
140 | 	*destination = '\0';
141 |  
142 | 	// the destination is returned by standard `strcpy()`
143 | 	return ptr;
144 | }
145 | 
146 | 
147 | int atoi(const char *nptr) {
148 | 	// Initialize result
149 | 	int res = 0;
150 | 
151 | 	// Iterate through all characters
152 | 	// of input string and update result
153 | 	// take ASCII character of corresponding digit and
154 | 	// subtract the code from '0' to get numerical
155 | 	// value and multiply res by 10 to shuffle
156 | 	// digits left to update running total
157 | 	for (int i = 0; nptr[i] != '\0'; ++i) {
158 | 		res = res * 10 + nptr[i] - '0';
159 | 	}
160 | 
161 | 	// return result.
162 | 	return res;
163 | }
164 | 
165 | void *memmove(void *dest, const void *src, size_t n) {
166 | 	assert((n != 0));
167 | 	assert((dest > (void *)4096));
168 | 	assert((src  > (void *)4096));
169 | 	assert((dest != src));
170 | 	uint8_t* dst = (uint8_t*) dest;
171 | 	const uint8_t* srcTemp = (const uint8_t*) src;
172 | 	if (dst < srcTemp) {
173 | 		for (size_t i = 0; i < n; i++) {
174 | 			dst[i] = srcTemp[i];
175 | 		}
176 | 	}
177 | 	else {
178 | 		for (size_t i = n; i != 0; i--) {
179 | 			dst[i - 1] = srcTemp[i - 1];
180 | 		}
181 | 	}
182 | 	return dest;
183 | }


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | # This is the name that our final kernel executable will have.
  2 | # Change as needed.
  3 | override KERNEL := bin/kernel.elf
  4 |  
  5 | # Convenience macro to reliably declare overridable command variables.
  6 | define DEFAULT_VAR =
  7 | 	ifeq ($(origin $1),default)
  8 | 		override $(1) := $(2)
  9 | 	endif
 10 | 	ifeq ($(origin $1),undefined)
 11 | 		override $(1) := $(2)
 12 | 	endif
 13 | endef
 14 |  
 15 | # It is highly recommended to use a custom built cross toolchain to build a kernel.
 16 | # We are only using "cc" as a placeholder here. It may work by using
 17 | # the host system's toolchain, but this is not guaranteed.
 18 | $(eval $(call DEFAULT_VAR,CC,cc))
 19 |  
 20 | # Same thing for "ld" (the linker).
 21 | $(eval $(call DEFAULT_VAR,LD,ld))
 22 |  
 23 | # User controllable CFLAGS.
 24 | CFLAGS ?= -g -Wall -Wextra -pipe
 25 |  
 26 | # User controllable preprocessor flags. We set none by default.
 27 | #CPPFLAGS ?= -Wno-c++20-extensions -fno-threadsafe-statics
 28 |  
 29 | # User controllable nasm flags.
 30 | NASMFLAGS ?= -F dwarf -g
 31 |  
 32 | # User controllable linker flags. We set none by default.
 33 | LDFLAGS ?= 
 34 |  
 35 | # Internal C flags that should not be changed by the user.
 36 | override CFLAGS +=       \
 37 | 	-std=gnu2x           \
 38 | 	-I.                  \
 39 | 	-ffreestanding       \
 40 | 	-fno-stack-protector \
 41 | 	-fno-stack-check     \
 42 | 	-fno-pie             \
 43 | 	-fno-pic             \
 44 | 	-m64                 \
 45 | 	-march=x86-64        \
 46 | 	-mabi=sysv           \
 47 | 	-mno-80387			 \
 48 | 	-mno-mmx             \
 49 | 	-mno-sse             \
 50 | 	-mno-sse2            \
 51 | 	-mno-red-zone        \
 52 | 	-mcmodel=kernel      \
 53 | 	-Iinclude/ \
 54 | 	-include include/forceInclude.h \
 55 | 	-Wno-unused-parameter \
 56 | 	-Wno-missing-field-initializers \
 57 | 	-Wno-address \
 58 | 	-Wno-int-to-pointer-cast \
 59 | 	-Wno-pointer-arith \
 60 | 	-Wno-write-strings \
 61 | 	-Wno-cast-function-type \
 62 | 	-Wno-return-type \
 63 | 	-nostdlib
 64 | 
 65 | # Internal linker flags that should not be changed by the user.
 66 | override LDFLAGS +=         \
 67 | 	-nostdlib               \
 68 | 	-static                 \
 69 | 	-z max-page-size=0x1000 \
 70 | 	-T linker.ld
 71 |  
 72 | # Internal nasm flags that should not be changed by the user.
 73 | override NASMFLAGS += \
 74 | 	-f elf64
 75 | 
 76 | # Use find to glob all *.c, *.S, and *.asm files in the directory and extract the object names.
 77 | #override CPPFILES  := $(shell cd kernel && find . -type f -name '*.cpp')
 78 | override NASMFILES := $(shell cd kernel && find . -type f -name '*.asm')
 79 | override CFILES    := $(shell cd kernel && find . -type f -name '*.c')
 80 | #override OBJ_CPP   := $(subst .cpp,.o,$(CPPFILES))
 81 | override OBJ_C     := $(subst .c,.o,$(CFILES))
 82 | override OBJ_ASM   := $(subst .asm,.o,$(NASMFILES))
 83 | override OBJ       := $(subst ./,build/kernel/,$(OBJ_ASM) $(OBJ_C)) build/font.f16.bin.o
 84 | 
 85 | #test:
 86 | #	@echo $(OBJ)
 87 |  
 88 | # Default target.
 89 | .PHONY: all
 90 | all: $(KERNEL) 
 91 | 
 92 | # Link rules for the final kernel executable.
 93 | $(KERNEL): $(OBJ)
 94 | 	@mkdir -p $(@D) 
 95 | 	@echo "   LD    $(subst build/,,$(subst ./,,$(subst kernel/,,$(OBJ)))) ==> $@"
 96 | 	@$(LD) $(subst ./,build/,$(OBJ)) $(LDFLAGS) -o $@
 97 |  
 98 | # Compilation rules for *.c files.
 99 | # build/%.o: %.cpp
100 | #	@mkdir -p $(@D)
101 | #	@echo "   CXX   $@"
102 | #	@g++ $(CPPFLAGS) $(CFLAGS) -c $< -o $@
103 |  
104 | build/%.o: %.c
105 | 	@mkdir -p $(@D)
106 | 	@echo "   CC    $@"
107 | 	@gcc $(CFLAGS) -std=gnu2x -c $< -o $@
108 | 
109 | # Compilation rules for *.asm (nasm) files.
110 | build/%.o: %.asm
111 | 	@mkdir -p $(@D)
112 | 	@echo "   NASM  $@"
113 | 	@nasm $(NASMFLAGS) $< -o $@
114 | 
115 | build/font.f16.bin.o: vgafont.f16
116 | 	@$(info $s   PERL  vgafont.f16 ==> font.f16.c)
117 | 	@perl tools/navcc.perl vgafont.f16 > build/font.f16.c
118 | 	@$(info $s   CC    font.f16.c ==> font.bin.f16.o)
119 | 	@$(CC) -c -Wno-gnu-binary-literal -std=gnu2x build/font.f16.c -o build/font.f16.bin.o
120 | 
121 | # Remove object files and the final executable.
122 | .PHONY: clean
123 | clean:
124 | 	@rm -rf $(KERNEL) $(OBJ) $(HEADER_DEPS) limine initramfs iso_root/ bin/*
125 | 	@echo "Cleaned!"
126 | 
127 | initramfs:
128 | 	@tar -cf initramfs --format=ustar -C rootfs/ .
129 | 
130 | limine.h:
131 | 	@wget https://raw.githubusercontent.com/limine-bootloader/limine/trunk/limine.h -q
132 | 
133 | iso: $(kernel)
134 | 	@make limine.h
135 | 	@make
136 | 	@make initramfs
137 | 	@rm -rf limine/
138 | 	@git clone https://github.com/limine-bootloader/limine.git --branch=v7.x-binary --depth=1 --quiet
139 | 	
140 | 	@mkdir -p iso_root
141 |  
142 | 	@cp bin/kernel.elf initramfs limine.cfg limine/*.sys \
143 | 	  limine/*.bin iso_root/
144 |  
145 | 	@./tools/iso.sh
146 | 
147 | test.disk:
148 | 	qemu-img create test.disk 1G
149 | 
150 | run: iso test.disk
151 | 	@qemu-system-x86_64 -hda test.disk -cdrom bin/image.iso -bios ./OVMF_CODE.fd -debugcon stdio -m 1G -smp 3 --enable-kvm -M q35
152 | 
153 | debug: iso test.disk
154 | 	@qemu-system-x86_64 -hda test.disk -cdrom bin/image.iso -bios ./OVMF_CODE.fd -debugcon stdio -m 1G -d int -D log.txt -no-reboot -no-shutdown  -M q35


--------------------------------------------------------------------------------
/kernel/userinput/mouse.c:
--------------------------------------------------------------------------------
  1 | #include <userinput/mouse.h>
  2 | #include <idt/interrupts.h>
  3 | #include <tty/fbCon.h>
  4 | #include <io.h>
  5 | 
  6 | Mouse GlobalMouse;
  7 | 
  8 | void MouseWait()
  9 | {
 10 |     uint64_t timeout = 100000;
 11 |     while (timeout--)
 12 |     {
 13 |         if ((inb(0x64) & 0b10) == 0)
 14 |         {
 15 |             return;
 16 |         }
 17 |     }
 18 | }
 19 | 
 20 | void MouseWaitInput()
 21 | {
 22 |     uint64_t timeout = 100000;
 23 |     while (timeout--)
 24 |     {
 25 |         if (inb(0x64) & 0b1)
 26 |         {
 27 |             return;
 28 |         }
 29 |     }
 30 | }
 31 | 
 32 | void MouseWrite(uint8_t value)
 33 | {
 34 |     MouseWait();
 35 |     outb(0x64, 0xD4);
 36 |     MouseWait();
 37 |     outb(0x60, value);
 38 | 
 39 | }
 40 | 
 41 | uint8_t MouseRead()
 42 | {
 43 |     MouseWaitInput();
 44 |     return inb(0x60);
 45 | }
 46 | 
 47 | uint8_t MouseCycle = 0;
 48 | uint8_t MousePacket[4];
 49 | bool MousePacketReady = false;
 50 | point_t MousePosition;
 51 | point_t MousePositionOld;
 52 | 
 53 | void HandlePS2Mouse(uint8_t data)
 54 | {
 55 | 
 56 |     ProcessMousePacket();
 57 |     static bool skip = true;
 58 |     if (skip)
 59 |     {
 60 |         skip = false;
 61 |         return;
 62 |     }
 63 | 
 64 |     switch (MouseCycle)
 65 |     {
 66 |     case 0:
 67 | 
 68 |         if ((data & 0b00001000) == 0)
 69 |             break;
 70 |         MousePacket[0] = data;
 71 |         MouseCycle++;
 72 |         break;
 73 |     case 1:
 74 | 
 75 |         MousePacket[1] = data;
 76 |         MouseCycle++;
 77 |         break;
 78 |     case 2:
 79 | 
 80 |         MousePacket[2] = data;
 81 |         MousePacketReady = true;
 82 |         MouseCycle = 0;
 83 |         break;
 84 |     }
 85 | }
 86 | 
 87 | void ProcessMousePacket()
 88 | {
 89 |     if (!MousePacketReady)
 90 |         return;
 91 | 
 92 |     bool xNegative, yNegative, xOverflow, yOverflow;
 93 | 
 94 |     if (MousePacket[0] & PS2XSign)
 95 |     {
 96 |         xNegative = true;
 97 |     }
 98 |     else
 99 |         xNegative = false;
100 | 
101 |     if (MousePacket[0] & PS2YSign)
102 |     {
103 |         yNegative = true;
104 |     }
105 |     else
106 |         yNegative = false;
107 | 
108 |     if (MousePacket[0] & PS2XOverflow)
109 |     {
110 |         xOverflow = true;
111 |     }
112 |     else
113 |         xOverflow = false;
114 | 
115 |     if (MousePacket[0] & PS2YOverflow)
116 |     {
117 |         yOverflow = true;
118 |     }
119 |     else
120 |         yOverflow = false;
121 | 
122 |     if (!xNegative)
123 |     {
124 |         MousePosition.X += MousePacket[1];
125 |         if (xOverflow)
126 |         {
127 |             MousePosition.X += 255;
128 |         }
129 |     }
130 |     else
131 |     {
132 |         MousePacket[1] = 256 - MousePacket[1];
133 |         MousePosition.X -= MousePacket[1];
134 |         if (xOverflow)
135 |         {
136 |             MousePosition.X -= 255;
137 |         }
138 |     }
139 | 
140 |     if (!yNegative)
141 |     {
142 |         MousePosition.Y -= MousePacket[2];
143 |         if (yOverflow)
144 |         {
145 |             MousePosition.Y -= 255;
146 |         }
147 |     }
148 |     else
149 |     {
150 |         MousePacket[2] = 256 - MousePacket[2];
151 |         MousePosition.Y += MousePacket[2];
152 |         if (yOverflow)
153 |         {
154 |             MousePosition.Y += 255;
155 |         }
156 |     }
157 | 
158 |     if (MousePosition.X > fbCon.width - 1)
159 |         MousePosition.X = fbCon.width - 1;
160 | 
161 |     if (MousePosition.Y > fbCon.height - 1)
162 |         MousePosition.Y = fbCon.height - 1;
163 | 
164 |     comout("\nMousePositionOld.X: ");
165 |     comout_num(MousePositionOld.X);
166 |     comout("\nMousePositionOld.Y: ");
167 |     comout_num(MousePositionOld.Y);
168 |     
169 |     comout("\nMousePosition.X: ");
170 |     comout_num(MousePosition.X);
171 |     comout("\nMousePosition.Y: ");
172 |     comout_num(MousePosition.Y);
173 | 
174 |     ClearMouseCursor(MousePositionOld);
175 |     DrawOverlayMouseCursor(MousePosition);
176 | 
177 |     if (MousePacket[0] & PS2Leftbutton)
178 |     {
179 |         GlobalMouse.LeftDown = true;
180 |     }
181 |     if (MousePacket[0] & PS2Middlebutton)
182 |     {
183 |         GlobalMouse.MiddleDown = true;
184 |     }   
185 |     if (MousePacket[0] & PS2Rightbutton)
186 |     {
187 |         GlobalMouse.RightDown = true;
188 |     }
189 | 
190 |     GlobalMouse.pos.X = MousePosition.X;
191 |     GlobalMouse.pos.Y = MousePosition.Y;
192 | 
193 |     MousePacketReady = false;
194 |     MousePositionOld = MousePosition;
195 | }
196 | 
197 | void InitPS2Mouse()
198 | {
199 |     outb(0x64, 0xA8); // enabling the auxiliary device - mouse
200 |     MouseWait();
201 |     
202 |     outb(0x64, 0x20); // tells the keyboard controller that we want to send a command to the mouse
203 |     MouseWaitInput();
204 |     
205 |     uint8_t status = inb(0x60) | 2;
206 |     
207 |     MouseWait();
208 |     outb(0x64, 0x60);
209 |     MouseWait();
210 |     
211 |     outb(0x60, status); // setting the correct bit is the "compaq" status byte
212 |     MouseWrite(0xF6);
213 | 
214 |     MouseRead();
215 | 
216 |     MouseWrite(0xF4);
217 | 
218 |     MouseRead();
219 | }
220 | 
221 | 


--------------------------------------------------------------------------------
/kernel/video/ansi.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ======================
  3 | The original version of this file is Copyright (C)Techflash Software, 2021 - 2023.
  4 | This is code from "Techflash OS", the hobbyist operating system developed by Techflash.
  5 | You may find the original code at https://github.com/techflashYT/Techflash-OS/blob/master/kernel/tty/ansi.c
  6 | ======================
  7 | */
  8 | 
  9 | #include <stdbool.h>
 10 | #include <stdlib.h>
 11 | #include <stdio.h>
 12 | #include <string.h>
 13 | #include <stddef.h>
 14 | #include <tty.h>
 15 | #include <tty/fbCon.h>
 16 | 
 17 | bool escapeCompleted = false;
 18 | char escapeSequence[256];
 19 | int escapeSequenceLength = 0;
 20 | bool TTY_HandleEsc(char ch) {
 21 |     escapeSequence[escapeSequenceLength++] = ch;
 22 |     escapeSequence[escapeSequenceLength] = '\0';
 23 | 
 24 |     // Check if the escape sequence has completed
 25 |     if (ch >= 0x40 && ch <= 0x7E) {
 26 | 
 27 |         // Parse color codes from the escape sequence
 28 |         char* colorCodeStart = strstr(escapeSequence, "[");
 29 |         if (colorCodeStart != NULL) {
 30 |             char* colorCodeEnd = strstr(colorCodeStart, "m");
 31 |             if (colorCodeEnd != NULL) {
 32 |                 // it was able to find the `m`, therefore it is now done
 33 |                 escapeCompleted = true;
 34 |                 // Extract the color code substring
 35 |                 size_t codeLength = (size_t)(colorCodeEnd - colorCodeStart - 1);
 36 |                 char colorCode[codeLength + 1];
 37 |                 memcpy(colorCode, colorCodeStart + 1, codeLength);
 38 |                 colorCode[codeLength] = '\0';
 39 | 
 40 |                 // Handle color and attribute switching based on the color code
 41 |                 int code = atoi(colorCode);
 42 |                 switch (code) {
 43 |                     case 0:
 44 |                         // Reset all attributes
 45 |                         TTY_Color = COLOR_LGRAY;
 46 |                         TTY_BgColor = COLOR_BLACK;
 47 |                         TTY_Bold = false;
 48 |                         // TODO: TTY_Underline = false;
 49 |                         break;
 50 |                     case 1:
 51 |                         // Set text style to bold
 52 |                         TTY_Bold = true;
 53 |                         break;
 54 |                     case 22:
 55 |                         // Disable bold
 56 |                         TTY_Bold = false;
 57 |                         break;
 58 |                     case 30:
 59 |                         // Set text color to black
 60 |                         TTY_Color = COLOR_BLACK;
 61 |                         break;
 62 |                     case 31:
 63 |                         // Set text color to red
 64 |                         TTY_Color = COLOR_RED;
 65 |                         break;
 66 |                     case 32:
 67 |                         // Set text color to green
 68 |                         TTY_Color = COLOR_GREEN;
 69 |                         break;
 70 |                     case 33:
 71 |                         // Set text color to yellow
 72 |                         TTY_Color = COLOR_YELLOW;
 73 |                         break;
 74 |                     case 34:
 75 |                         // Set text color to blue
 76 |                         TTY_Color = COLOR_BLUE;
 77 |                         break;
 78 |                     case 35:
 79 |                         // Set text color to magenta
 80 |                         TTY_Color = COLOR_PURPLE;
 81 |                         break;
 82 |                     case 36:
 83 |                         // Set text color to cyan
 84 |                         TTY_Color = COLOR_CYAN;
 85 |                         break;
 86 |                     case 37:
 87 |                         // Set text color to white
 88 |                         TTY_Color = COLOR_LGRAY;
 89 |                         break;
 90 |                     case 40:
 91 |                         // Set background color to black
 92 |                         TTY_BgColor = COLOR_BLACK;
 93 |                         break;
 94 |                     case 41:
 95 |                         // Set background color to red
 96 |                         TTY_BgColor = COLOR_RED;
 97 |                         break;
 98 |                     case 42:
 99 |                         // Set background color to green
100 |                         TTY_BgColor = COLOR_GREEN;
101 |                         break;
102 |                     case 43:
103 |                         // Set background color to yellow
104 |                         TTY_BgColor = COLOR_YELLOW;
105 |                         break;
106 |                     case 44:
107 |                         // Set background color to blue
108 |                         TTY_BgColor = COLOR_BLUE;
109 |                         break;
110 |                     case 45:
111 |                         // Set background color to magenta
112 |                         TTY_BgColor = COLOR_PURPLE;
113 |                         break;
114 |                     case 46:
115 |                         // Set background color to cyan
116 |                         TTY_BgColor = COLOR_CYAN;
117 |                         break;
118 |                     case 47:
119 |                         // Set background color to white
120 |                         TTY_BgColor = COLOR_LGRAY;
121 |                         break;
122 |                     default:
123 |                         // Unsupported color code, do nothing
124 |                         break;
125 |                 }
126 |             }
127 |         }
128 |     }
129 |     if (escapeCompleted) {
130 |         escapeCompleted = false;
131 |         escapeSequenceLength = 0;
132 |         return true;
133 |     }
134 |     return false;    
135 | }
136 | 


--------------------------------------------------------------------------------
/kernel/disks/sata.c:
--------------------------------------------------------------------------------
  1 | #include <stdint.h>
  2 | #include <memory/malloc.h>
  3 | #include <pci/pci.h>
  4 | #include <disks/sata.h>
  5 | #include <stdio.h>
  6 | 
  7 | MODULE("SATA");
  8 | 
  9 | 
 10 | #define HBA_PORT_DEV_PRESENT 0x3
 11 | #define HBA_PORT_IPM_ACTIVE 0x1
 12 | #define SATA_SIG_ATAPI 0xEB140101
 13 | #define SATA_SIG_ATA 0x00000101
 14 | #define SATA_SIG_SEMB 0xC33C0101
 15 | #define SATA_SIG_PM 0x96690101
 16 | 
 17 | #define HBA_PxCMD_CR 0x8000
 18 | #define HBA_PxCMD_FRE 0x0010
 19 | #define HBA_PxCMD_ST 0x0001
 20 | #define HBA_PxCMD_FR 0x4000
 21 | 
 22 | #define ATA_DEV_BUSY 0x80
 23 | #define ATA_DEV_DRQ 0x08
 24 | #define ATA_CMD_READ_DMA_EX 0x25
 25 | #define HBA_PxIS_TFES (1 << 30)
 26 | 
 27 | PortType CheckPortType(HBAPort* port) {
 28 |     uint32_t sataStatus = port->sataStatus;
 29 |     uint8_t interfacePowerManagement = (sataStatus >> 8) & 0b111;
 30 |     uint8_t deviceDetection = sataStatus & 0b111;
 31 | 
 32 |     if (deviceDetection != HBA_PORT_DEV_PRESENT)
 33 |         return None;
 34 |     if (interfacePowerManagement != HBA_PORT_IPM_ACTIVE)
 35 |         return None;
 36 | 
 37 |     switch (port->signature) {
 38 |         case SATA_SIG_ATAPI:
 39 |             return SATAPI;
 40 |         case SATA_SIG_ATA:
 41 |             return SATA;
 42 |         case SATA_SIG_PM:
 43 |             return PM;
 44 |         case SATA_SIG_SEMB:
 45 |             return SEMB;
 46 |         default:
 47 |             return None;
 48 |     }
 49 | }
 50 | 
 51 | void ProbePorts(AHCIDriver* driver) {
 52 |     uint32_t portsImplemented = driver->ABAR->portsImplemented;
 53 |     for (int i = 0; i < 32; i++) {
 54 |         if (portsImplemented & (1 << i)) {
 55 |             PortType portType = CheckPortType(&driver->ABAR->ports[i]);
 56 | 
 57 |             if (portType == SATA || portType == SATAPI) {
 58 |                 driver->ports[driver->portCount] = (Port*)malloc(sizeof(Port));
 59 |                 driver->ports[driver->portCount]->portType = portType;
 60 |                 driver->ports[driver->portCount]->hbaPort = &driver->ABAR->ports[i];
 61 |                 driver->ports[driver->portCount]->portNumber = driver->portCount;
 62 |                 driver->portCount++;
 63 |             }
 64 |         }
 65 |     }
 66 | }
 67 | 
 68 | void Configure(Port* port) {
 69 |     StopCMD(port);
 70 | 
 71 |     void* newBase = malloc(4096);
 72 |     port->hbaPort->commandListBase = (uint32_t)(uint64_t)newBase;
 73 |     port->hbaPort->commandListBaseUpper = (uint32_t)((uint64_t)newBase >> 32);
 74 |     memset((void*)(port->hbaPort->commandListBase), 0, 1024);
 75 | 
 76 |     void* fisBase = malloc(4096);
 77 |     port->hbaPort->fisBaseAddress = (uint32_t)(uint64_t)fisBase;
 78 |     port->hbaPort->fisBaseAddressUpper = (uint32_t)((uint64_t)fisBase >> 32);
 79 |     memset(fisBase, 0, 256);
 80 | 
 81 |     HBACommandHeader* cmdHeader = (HBACommandHeader*)((uint64_t)port->hbaPort->commandListBase + ((uint64_t)port->hbaPort->commandListBaseUpper << 32));
 82 | 
 83 |     for (int i = 0; i < 32; i++) {
 84 |         cmdHeader[i].prdtLength = 8;
 85 | 
 86 |         void* cmdTableAddress = malloc(4096);
 87 |         uint64_t address = (uint64_t)cmdTableAddress + (i << 8);
 88 |         cmdHeader[i].commandTableBaseAddress = (uint32_t)(uint64_t)address;
 89 |         cmdHeader[i].commandTableBaseAddressUpper = (uint32_t)((uint64_t)address >> 32);
 90 |         memset(cmdTableAddress, 0, 256);
 91 |     }
 92 | 
 93 |     StartCMD(port);
 94 | }
 95 | 
 96 | void StopCMD(Port* port) {
 97 |     port->hbaPort->cmdSts &= ~HBA_PxCMD_ST;
 98 |     port->hbaPort->cmdSts &= ~HBA_PxCMD_FRE;
 99 | 
100 |     while (1) {
101 |         if (port->hbaPort->cmdSts & HBA_PxCMD_FR)
102 |             continue;
103 |         if (port->hbaPort->cmdSts & HBA_PxCMD_CR)
104 |             continue;
105 | 
106 |         break;
107 |     }
108 | }
109 | 
110 | void StartCMD(Port* port) {
111 |     while (port->hbaPort->cmdSts & HBA_PxCMD_CR);
112 | 
113 |     port->hbaPort->cmdSts |= HBA_PxCMD_FRE;
114 |     port->hbaPort->cmdSts |= HBA_PxCMD_ST;
115 | }
116 | 
117 | int Read(Port* port, uint64_t sector, uint32_t sectorCount, void* buffer) {
118 |     uint32_t sectorL = (uint32_t)sector;
119 |     uint32_t sectorH = (uint32_t)(sector >> 32);
120 | 
121 |     port->hbaPort->interruptStatus = (uint32_t)-1; // Clear pending interrupt bits
122 | 
123 |     HBACommandHeader* cmdHeader = (HBACommandHeader*)port->hbaPort->commandListBase;
124 |     cmdHeader->commandFISLength = sizeof(FIS_REG_H2D) / sizeof(uint32_t); // command FIS size;
125 |     cmdHeader->write = 0; // this is a read
126 |     cmdHeader->prdtLength = 1;
127 | 
128 |     HBACommandTable* commandTable = (HBACommandTable*)(cmdHeader->commandTableBaseAddress);
129 |     memset(commandTable, 0, sizeof(HBACommandTable) + (cmdHeader->prdtLength - 1) * sizeof(HBAPRDTEntry));
130 | 
131 |     commandTable->prdtEntry[0].dataBaseAddress = (uint32_t)(uint64_t)buffer;
132 |     commandTable->prdtEntry[0].dataBaseAddressUpper = (uint32_t)((uint64_t)buffer >> 32);
133 |     commandTable->prdtEntry[0].byteCount = (sectorCount << 9) - 1; // 512 bytes per sector
134 |     commandTable->prdtEntry[0].interruptOnCompletion = 1;
135 | 
136 |     FIS_REG_H2D* cmdFIS = (FIS_REG_H2D*)(&commandTable->commandFIS);
137 | 
138 |     cmdFIS->fisType = FIS_TYPE_REG_H2D;
139 |     cmdFIS->commandControl = 1; // command
140 |     cmdFIS->command = ATA_CMD_READ_DMA_EX;
141 | 
142 |     cmdFIS->lba0 = (uint8_t)sectorL;
143 |     cmdFIS->lba1 = (uint8_t)(sectorL >> 8);
144 |     cmdFIS->lba2 = (uint8_t)(sectorL >> 16);
145 |     cmdFIS->lba3 = (uint8_t)sectorH;
146 |     cmdFIS->lba4 = (uint8_t)(sectorH >> 8);
147 |     cmdFIS->lba4 = (uint8_t)(sectorH >> 16);
148 | 
149 |     cmdFIS->deviceRegister = 1 << 6; // LBA mode
150 | 
151 |     cmdFIS->countLow = sectorCount & 0xFF;
152 |     cmdFIS->countHigh = (sectorCount >> 8) & 0xFF;
153 | 
154 |     uint64_t spin = 0;
155 | 
156 |     while ((port->hbaPort->taskFileData & (ATA_DEV_BUSY | ATA_DEV_DRQ)) && spin < 1000000) {
157 |         spin++;
158 |     }
159 |     if (spin == 1000000) {
160 |         return 0;
161 |     }
162 | 
163 |     port->hbaPort->commandIssue = 1;
164 | 
165 |     while (1) {
166 |         if ((port->hbaPort->commandIssue == 0))
167 |             break;
168 |         if (port->hbaPort->interruptStatus & HBA_PxIS_TFES) {
169 |             return 0;
170 |         }
171 |     }
172 | 
173 |     return 1;
174 | }
175 | 
176 | AHCIDriver* AHCIDriver_Init(PCIDeviceHeader* pciBaseAddress) {
177 | 	log("SATA drive detected", LOGLEVEL_INFO);
178 | 
179 |     AHCIDriver* driver = (AHCIDriver*)malloc(sizeof(AHCIDriver));
180 |     driver->PCIBaseAddress = pciBaseAddress;
181 |     
182 |     driver->ABAR = (HBAMemory *)((PCIHeader0 *)pciBaseAddress)->BAR5;
183 | 
184 |     ProbePorts(driver);
185 |     
186 |     for (int i = 0; i < driver->portCount; i++)
187 |     {
188 |         Port* port = driver->ports[i];
189 |         Configure(port);
190 | 
191 |         port->buffer = (uint8_t*)malloc(4096);
192 |         memset(port->buffer, 0, 0x1000);
193 |     }    
194 | 
195 |     return driver;
196 | }
197 | 
198 | void AHCIDriver_Destroy(AHCIDriver* driver) {
199 |     free(driver);
200 | }


--------------------------------------------------------------------------------
/kernel/pci/pciDesc.c:
--------------------------------------------------------------------------------
  1 | #include <stdint.h>
  2 | #include <string.h>
  3 | 
  4 | const char *DeviceClasses[] = {
  5 |     "Unclassified",
  6 |     "Mass Storage Controller",
  7 |     "Network Controller",
  8 |     "Display Controller",
  9 |     "Multimedia Controller",
 10 |     "Memory Controller",
 11 |     "Bridge Device",
 12 |     "Simple Communication Controller",
 13 |     "Base System Peripheral",
 14 |     "Input Device Controller",
 15 |     "Docking Station",
 16 |     "Processor",
 17 |     "Serial Bus Controller",
 18 |     "Wireless Controller",
 19 |     "Intelligent Controller",
 20 |     "Satellite Communication Controller",
 21 |     "Encryption Controller",
 22 |     "Signal Processing Controller",
 23 |     "Processing Accelerator",
 24 |     "Non Essential Instrumentation"
 25 | };
 26 | 
 27 | const char *GetVendorName(uint16_t vendorID) {
 28 |     switch (vendorID) {
 29 |         case 0x8086:
 30 |             return "Intel Corp";
 31 |         case 0x1022:
 32 |             return "AMD";
 33 |         case 0x10DE:
 34 |             return "NVIDIA Corporation";
 35 |     }
 36 |     return to_hstring(vendorID);
 37 | }
 38 | 
 39 | const char *GetDeviceName(uint16_t vendorID, uint16_t deviceID) {
 40 |     switch (vendorID) {
 41 |     case 0x8086: // Intel
 42 |         switch (deviceID) {
 43 |             case 0x29C0:
 44 |                 return "Express DRAM Controller";
 45 |             case 0x2918:
 46 |                 return "LPC Interface Controller";
 47 |             case 0x2922:
 48 |                 return "6 port SATA Controller [AHCI mode]";
 49 |             case 0x2930:
 50 |                 return "SMBus Controller";
 51 |         }
 52 |     }
 53 |     return to_hstring(deviceID);
 54 | }
 55 | 
 56 | const char *MassStorageControllerSubclassName(uint8_t subclassCode) {
 57 |     switch (subclassCode) {
 58 |         case 0x00:
 59 |             return "SCSI Bus Controller";
 60 |         case 0x01:
 61 |             return "IDE Controller";
 62 |         case 0x02:
 63 |             return "Floppy Disk Controller";
 64 |         case 0x03:
 65 |             return "IPI Bus Controller";
 66 |         case 0x04:
 67 |             return "RAID Controller";
 68 |         case 0x05:
 69 |             return "ATA Controller";
 70 |         case 0x06:
 71 |             return "Serial ATA";
 72 |         case 0x07:
 73 |             return "Serial Attached SCSI";
 74 |         case 0x08:
 75 |             return "Non-Volatile Memory Controller";
 76 |         case 0x80:
 77 |             return "Other";
 78 |     }
 79 |     return to_hstring(subclassCode);
 80 | }
 81 | 
 82 | const char *SerialBusControllerSubclassName(uint8_t subclassCode) {
 83 |     switch (subclassCode) {
 84 |         case 0x00:
 85 |             return "FireWire (IEEE 1394) Controller";
 86 |         case 0x01:
 87 |             return "ACCESS Bus";
 88 |         case 0x02:
 89 |             return "SSA";
 90 |         case 0x03:
 91 |             return "USB Controller";
 92 |         case 0x04:
 93 |             return "Fibre Channel";
 94 |         case 0x05:
 95 |             return "SMBus";
 96 |         case 0x06:
 97 |             return "Infiniband";
 98 |         case 0x07:
 99 |             return "IPMI Interface";
100 |         case 0x08:
101 |             return "SERCOS Interface (IEC 61491)";
102 |         case 0x09:
103 |             return "CANbus";
104 |         case 0x80:
105 |             return "SerialBusController - Other";
106 |     }
107 |     return to_hstring(subclassCode);
108 | }
109 | 
110 | const char *BridgeDeviceSubclassName(uint8_t subclassCode) {
111 |     switch (subclassCode) {
112 |         case 0x00:
113 |             return "Host Bridge";
114 |         case 0x01:
115 |             return "ISA Bridge";
116 |         case 0x02:
117 |             return "EISA Bridge";
118 |         case 0x03:
119 |             return "MCA Bridge";
120 |         case 0x04:
121 |             return "PCI-to-PCI Bridge";
122 |         case 0x05:
123 |             return "PCMCIA Bridge";
124 |         case 0x06:
125 |             return "NuBus Bridge";
126 |         case 0x07:
127 |             return "CardBus Bridge";
128 |         case 0x08:
129 |             return "RACEway Bridge";
130 |         case 0x09:
131 |             return "PCI-to-PCI Bridge";
132 |         case 0x0a:
133 |             return "InfiniBand-to-PCI Host Bridge";
134 |         case 0x80:
135 |             return "Other";
136 |     }
137 |     return to_hstring(subclassCode);
138 | }
139 | 
140 | const char *GetSubclassName(uint8_t classCode, uint8_t subclassCode) {
141 |     switch (classCode) {
142 |         case 0x01:
143 |             return MassStorageControllerSubclassName(subclassCode);
144 |         case 0x03: {
145 |             switch (subclassCode) {
146 |                 case 0x00:
147 |                     return "VGA Compatible Controller";
148 |             }
149 |             return "Unknown";
150 |         }
151 |         case 0x06:
152 |             return BridgeDeviceSubclassName(subclassCode);
153 |         case 0x0C:
154 |             return SerialBusControllerSubclassName(subclassCode);
155 |     }
156 |     return to_hstring(subclassCode);
157 | }
158 | 
159 | const char *GetProgIFName(uint8_t classCode, uint8_t subclassCode, uint8_t progIF) {
160 |     switch (classCode) {
161 |         case 0x01: {
162 |             switch (subclassCode) {
163 |                 case 0x06: {
164 |                     switch (progIF) {
165 |                         case 0x00:
166 |                             return "Vendor Specific Interface";
167 |                         case 0x01:
168 |                             return "AHCI 1.0";
169 |                         case 0x02:
170 |                             return "Serial Storage Bus";
171 |                     }
172 |                     return "Unknown";
173 |                 }
174 |             }
175 |             return "Unknown";
176 |         }
177 |         case 0x03: {
178 |             switch (subclassCode) {
179 |                 case 0x00: {
180 |                     switch (progIF) {
181 |                         case 0x00:
182 |                             return "VGA Controller";
183 |                         case 0x01:
184 |                             return "8514-Compatible Controller";
185 |                     }
186 |                     return "Unknown";
187 |                 }
188 |             }
189 |             return "Unknown";
190 |         }
191 |         case 0x0C: {
192 |             switch (subclassCode) {
193 |             case 0x03:
194 |                 switch (progIF) {
195 |                     case 0x00:
196 |                         return "UHCI Controller";
197 |                     case 0x10:
198 |                         return "OHCI Controller";
199 |                     case 0x20:
200 |                         return "EHCI (USB2) Controller";
201 |                     case 0x30:
202 |                         return "XHCI (USB3) Controller";
203 |                     case 0x80:
204 |                         return "Unspecified";
205 |                     case 0xFE:
206 |                         return "USB Device (Not a Host Controller)";
207 |                 }
208 |                 return "Unknown";
209 |             }
210 |         }
211 |     }
212 |     return to_hstring(progIF);
213 | }


--------------------------------------------------------------------------------
/kernel/video/printf.h:
--------------------------------------------------------------------------------
  1 | // NOTE: Follows same license as printf.c!
  2 | 
  3 | #include <stdarg.h>
  4 | #include <stddef.h>
  5 | #include <stdio.h>
  6 | #include <stdint.h>
  7 | #include <string.h>
  8 | #include <ctype.h>
  9 | 
 10 | // If you want to include this implementation file directly rather than
 11 | // link against, this will let you control the functions' visibility,
 12 | // e.g. make them static so as not to clash with other objects also
 13 | // using them.
 14 | #define PRINTF_VISIBILITY
 15 | 
 16 | 
 17 | // 'ntoa' conversion buffer size, this must be big enough to hold one converted
 18 | // numeric number including padded zeros (dynamically created on stack)
 19 | #ifndef PRINTF_INTEGER_BUFFER_SIZE
 20 | #define PRINTF_INTEGER_BUFFER_SIZE    32
 21 | #endif
 22 | 
 23 | // size of the fixed (on-stack) buffer for printing individual decimal numbers.
 24 | // this must be big enough to hold one converted floating-point value including
 25 | // padded zeros.
 26 | #ifndef PRINTF_DECIMAL_BUFFER_SIZE
 27 | #define PRINTF_DECIMAL_BUFFER_SIZE    32
 28 | #endif
 29 | 
 30 | // Support for the decimal notation floating point conversion specifiers (%f, %F)
 31 | #ifndef PRINTF_SUPPORT_DECIMAL_SPECIFIERS
 32 | #define PRINTF_SUPPORT_DECIMAL_SPECIFIERS 0
 33 | #endif
 34 | 
 35 | // Support for the exponential notation floating point conversion specifiers (%e, %g, %E, %G)
 36 | #ifndef PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 37 | #define PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS 0
 38 | #endif
 39 | 
 40 | // Support for the length write-back specifier (%n)
 41 | #ifndef PRINTF_SUPPORT_WRITEBACK_SPECIFIER
 42 | #define PRINTF_SUPPORT_WRITEBACK_SPECIFIER 1
 43 | #endif
 44 | 
 45 | // Default precision for the floating point conversion specifiers (the C standard sets this at 6)
 46 | #ifndef PRINTF_DEFAULT_FLOAT_PRECISION
 47 | #define PRINTF_DEFAULT_FLOAT_PRECISION  6
 48 | #endif
 49 | 
 50 | // According to the C languages standard, printf() and related functions must be able to print any
 51 | // integral number in floating-point notation, regardless of length, when using the %f specifier -
 52 | // possibly hundreds of characters, potentially overflowing your buffers. In this implementation,
 53 | // all values beyond this threshold are switched to exponential notation.
 54 | #ifndef PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL
 55 | #define PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL 9
 56 | #endif
 57 | 
 58 | // Support for the long long integral types (with the ll, z and t length modifiers for specifiers
 59 | // %d,%i,%o,%x,%X,%u, and with the %p specifier). Note: 'L' (long double) is not supported.
 60 | #ifndef PRINTF_SUPPORT_LONG_LONG
 61 | #define PRINTF_SUPPORT_LONG_LONG 1
 62 | #endif
 63 | 
 64 | // The number of terms in a Taylor series expansion of log_10(x) to
 65 | // use for approximation - including the power-zero term (i.e. the
 66 | // value at the point of expansion).
 67 | #ifndef PRINTF_LOG10_TAYLOR_TERMS
 68 | #define PRINTF_LOG10_TAYLOR_TERMS 4
 69 | #endif
 70 | 
 71 | #if PRINTF_LOG10_TAYLOR_TERMS <= 1
 72 | #error "At least one non-constant Taylor expansion is necessary for the log10() calculation"
 73 | #endif
 74 | 
 75 | // Be extra-safe, and don't assume format specifiers are completed correctly
 76 | // before the format string end.
 77 | #ifndef PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER
 78 | #define PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER 1
 79 | #endif
 80 | 
 81 | #define PRINTF_PREFER_DECIMAL     true
 82 | #define PRINTF_PREFER_EXPONENTIAL false
 83 | 
 84 | ///////////////////////////////////////////////////////////////////////////////
 85 | 
 86 | // The following will convert the number-of-digits into an exponential-notation literal
 87 | #define PRINTF_CONCATENATE(s1, s2) s1##s2
 88 | #define PRINTF_EXPAND_THEN_CONCATENATE(s1, s2) PRINTF_CONCATENATE(s1, s2)
 89 | #define PRINTF_FLOAT_NOTATION_THRESHOLD PRINTF_EXPAND_THEN_CONCATENATE(1e,PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL)
 90 | 
 91 | // internal flag definitions
 92 | #define FLAGS_ZEROPAD   (1U <<  0U)
 93 | #define FLAGS_LEFT      (1U <<  1U)
 94 | #define FLAGS_PLUS      (1U <<  2U)
 95 | #define FLAGS_SPACE     (1U <<  3U)
 96 | #define FLAGS_HASH      (1U <<  4U)
 97 | #define FLAGS_UPPERCASE (1U <<  5U)
 98 | #define FLAGS_CHAR      (1U <<  6U)
 99 | #define FLAGS_SHORT     (1U <<  7U)
100 | #define FLAGS_INT       (1U <<  8U)
101 | 	// Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
102 | #define FLAGS_LONG      (1U <<  9U)
103 | #define FLAGS_LONG_LONG (1U << 10U)
104 | #define FLAGS_PRECISION (1U << 11U)
105 | #define FLAGS_ADAPT_EXP (1U << 12U)
106 | #define FLAGS_POINTER   (1U << 13U)
107 | 	// Note: Similar, but not identical, effect as FLAGS_HASH
108 | #define FLAGS_SIGNED    (1U << 14U)
109 | 	// Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
110 | 
111 | #ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
112 | 
113 | #define FLAGS_INT8 FLAGS_CHAR
114 | 
115 | 
116 | #if   (SHRT_MAX   == 32767LL)
117 | #define FLAGS_INT16       FLAGS_SHORT
118 | #elif (INT_MAX    == 32767LL)
119 | #define FLAGS_INT16       FLAGS_INT
120 | #elif (LONG_MAX   == 32767LL)
121 | #define FLAGS_INT16       FLAGS_LONG
122 | #elif (LLONG_MAX  == 32767LL)
123 | #define FLAGS_INT16       FLAGS_LONG_LONG
124 | #else
125 | #error "No basic integer type has a size of 16 bits exactly"
126 | #endif
127 | 
128 | #if   (SHRT_MAX   == 2147483647LL)
129 | #define FLAGS_INT32       FLAGS_SHORT
130 | #elif (INT_MAX    == 2147483647LL)
131 | #define FLAGS_INT32       FLAGS_INT
132 | #elif (LONG_MAX   == 2147483647LL)
133 | #define FLAGS_INT32       FLAGS_LONG
134 | #elif (LLONG_MAX  == 2147483647LL)
135 | #define FLAGS_INT32       FLAGS_LONG_LONG
136 | #else
137 | #error "No basic integer type has a size of 32 bits exactly"
138 | #endif
139 | 
140 | #if   (SHRT_MAX   == 9223372036854775807LL)
141 | #define FLAGS_INT64       FLAGS_SHORT
142 | #elif (INT_MAX    == 9223372036854775807LL)
143 | #define FLAGS_INT64       FLAGS_INT
144 | #elif (LONG_MAX   == 9223372036854775807LL)
145 | #define FLAGS_INT64       FLAGS_LONG
146 | #elif (LLONG_MAX  == 9223372036854775807LL)
147 | #define FLAGS_INT64       FLAGS_LONG_LONG
148 | #else
149 | #error "No basic integer type has a size of 64 bits exactly"
150 | #endif
151 | 
152 | #endif // PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
153 | 
154 | 
155 | typedef unsigned int printfFlags_t;
156 | 
157 | #define BASE_BINARY    2
158 | #define BASE_OCTAL     8
159 | #define BASE_DECIMAL  10
160 | #define BASE_HEX      16
161 | 
162 | typedef uint8_t numericBase_t;
163 | 
164 | #if PRINTF_SUPPORT_LONG_LONG
165 | typedef unsigned long long printfUnsignedValue_t;
166 | typedef long long          printfSignedValue_t;
167 | #else
168 | typedef unsigned long printfUnsignedValue_t;
169 | typedef long          printfSignedValue_t;
170 | #endif
171 | 
172 | // The printf()-family functions return an `int`; it is therefore
173 | // unnecessary/inappropriate to use size_t - often larger than int
174 | // in practice - for non-negative related values, such as widths,
175 | // precisions, offsets into buffers used for printing and the sizes
176 | // of these buffers. instead, we use:
177 | typedef unsigned int printfSize_t;
178 | #define PRINTF_MAX_POSSIBLE_BUFFER_SIZE INT_MAX
179 | 	// If we were to nitpick, this would actually be INT_MAX + 1,
180 | 	// since INT_MAX is the maximum return value, which excludes the
181 | 	// trailing '\0'.
182 | 
183 | #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS)
184 | #include <float.h>
185 | #if FLT_RADIX != 2
186 | #error "Non-binary-radix floating-point types are unsupported."
187 | #endif
188 | 
189 | #if DBL_MANT_DIG == 24
190 | 
191 | #define DOUBLE_SIZE_IN_BITS 32
192 | typedef uint32_t double_uint_t;
193 | #define DOUBLE_EXPONENT_MASK 0xFFU
194 | #define DOUBLE_BASE_EXPONENT 127
195 | #define DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10 -38
196 | #define DOUBLE_MAX_SUBNORMAL_POWER_OF_10 1e-38
197 | 
198 | #elif DBL_MANT_DIG == 53
199 | 
200 | #define DOUBLE_SIZE_IN_BITS 64
201 | typedef uint64_t double_uint_t;
202 | #define DOUBLE_EXPONENT_MASK 0x7FFU
203 | #define DOUBLE_BASE_EXPONENT 1023
204 | #define DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10 -308
205 | #define DOUBLE_MAX_SUBNORMAL_POWER_OF_10 1e-308
206 | 
207 | #else
208 | #error "Unsupported double type configuration"
209 | #endif
210 | #define DOUBLE_STORED_MANTISSA_BITS (DBL_MANT_DIG - 1)
211 | 
212 | typedef union {
213 | 	double_uint_t U;
214 | 	double        F;
215 | } double_with_bit_access;
216 | 
217 | #define PRINTF_ABS(_x) ( (_x) > 0 ? (_x) : -(_x) )
218 | 
219 | #endif // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS)
220 | 
221 | // Note in particular the behavior here on LONG_MIN or LLONG_MIN; it is valid
222 | // and well-defined, but if you're not careful you can easily trigger undefined
223 | // behavior with -LONG_MIN or -LLONG_MIN
224 | #define ABS_FOR_PRINTING(_x) ((printfUnsignedValue_t) ( (_x) > 0 ? (_x) : -((printfSignedValue_t)_x) ))
225 | 
226 | // wrapper (used as buffer) for output function type
227 | //
228 | // One of the following must hold:
229 | // 1. max_chars is 0
230 | // 2. buffer is non-null
231 | // 3. function is non-null
232 | //
233 | // ... otherwise bad things will happen.
234 | typedef struct {
235 | 	void (*function)(char c, void* extra_arg);
236 | 	void* extra_function_arg;
237 | 	char* buffer;
238 | 	printfSize_t pos;
239 | 	printfSize_t max_chars;
240 | } outputGadget_t;


--------------------------------------------------------------------------------
/limine.h:
--------------------------------------------------------------------------------
  1 | #ifndef _LIMINE_H
  2 | #define _LIMINE_H 1
  3 | 
  4 | #ifdef __cplusplus
  5 | extern "C" {
  6 | #endif
  7 | 
  8 | #include <stdint.h>
  9 | 
 10 | /* Misc */
 11 | 
 12 | #ifdef LIMINE_NO_POINTERS
 13 | #  define LIMINE_PTR(TYPE) uint64_t
 14 | #else
 15 | #  define LIMINE_PTR(TYPE) TYPE
 16 | #endif
 17 | 
 18 | #define LIMINE_COMMON_MAGIC 0xc7b1dd30df4c8b88, 0x0a82e883a194f07b
 19 | 
 20 | struct limine_uuid {
 21 |     uint32_t a;
 22 |     uint16_t b;
 23 |     uint16_t c;
 24 |     uint8_t d[8];
 25 | };
 26 | 
 27 | #define LIMINE_MEDIA_TYPE_GENERIC 0
 28 | #define LIMINE_MEDIA_TYPE_OPTICAL 1
 29 | #define LIMINE_MEDIA_TYPE_TFTP 2
 30 | 
 31 | struct limine_file {
 32 |     uint64_t revision;
 33 |     LIMINE_PTR(void *) address;
 34 |     uint64_t size;
 35 |     LIMINE_PTR(char *) path;
 36 |     LIMINE_PTR(char *) cmdline;
 37 |     uint32_t media_type;
 38 |     uint32_t unused;
 39 |     uint32_t tftp_ip;
 40 |     uint32_t tftp_port;
 41 |     uint32_t partition_index;
 42 |     uint32_t mbr_disk_id;
 43 |     struct limine_uuid gpt_disk_uuid;
 44 |     struct limine_uuid gpt_part_uuid;
 45 |     struct limine_uuid part_uuid;
 46 | };
 47 | 
 48 | /* Boot info */
 49 | 
 50 | #define LIMINE_BOOTLOADER_INFO_REQUEST { LIMINE_COMMON_MAGIC, 0xf55038d8e2a1202f, 0x279426fcf5f59740 }
 51 | 
 52 | struct limine_bootloader_info_response {
 53 |     uint64_t revision;
 54 |     LIMINE_PTR(char *) name;
 55 |     LIMINE_PTR(char *) version;
 56 | };
 57 | 
 58 | struct limine_bootloader_info_request {
 59 |     uint64_t id[4];
 60 |     uint64_t revision;
 61 |     LIMINE_PTR(struct limine_bootloader_info_response *) response;
 62 | };
 63 | 
 64 | /* Stack size */
 65 | 
 66 | #define LIMINE_STACK_SIZE_REQUEST { LIMINE_COMMON_MAGIC, 0x224ef0460a8e8926, 0xe1cb0fc25f46ea3d }
 67 | 
 68 | struct limine_stack_size_response {
 69 |     uint64_t revision;
 70 | };
 71 | 
 72 | struct limine_stack_size_request {
 73 |     uint64_t id[4];
 74 |     uint64_t revision;
 75 |     LIMINE_PTR(struct limine_stack_size_response *) response;
 76 |     uint64_t stack_size;
 77 | };
 78 | 
 79 | /* HHDM */
 80 | 
 81 | #define LIMINE_HHDM_REQUEST { LIMINE_COMMON_MAGIC, 0x48dcf1cb8ad2b852, 0x63984e959a98244b }
 82 | 
 83 | struct limine_hhdm_response {
 84 |     uint64_t revision;
 85 |     uint64_t offset;
 86 | };
 87 | 
 88 | struct limine_hhdm_request {
 89 |     uint64_t id[4];
 90 |     uint64_t revision;
 91 |     LIMINE_PTR(struct limine_hhdm_response *) response;
 92 | };
 93 | 
 94 | /* Framebuffer */
 95 | 
 96 | #define LIMINE_FRAMEBUFFER_REQUEST { LIMINE_COMMON_MAGIC, 0x9d5827dcd881dd75, 0xa3148604f6fab11b }
 97 | 
 98 | #define LIMINE_FRAMEBUFFER_RGB 1
 99 | 
100 | struct limine_framebuffer {
101 |     LIMINE_PTR(void *) address;
102 |     uint64_t width;
103 |     uint64_t height;
104 |     uint64_t pitch;
105 |     uint16_t bpp;
106 |     uint8_t memory_model;
107 |     uint8_t red_mask_size;
108 |     uint8_t red_mask_shift;
109 |     uint8_t green_mask_size;
110 |     uint8_t green_mask_shift;
111 |     uint8_t blue_mask_size;
112 |     uint8_t blue_mask_shift;
113 |     uint8_t unused[7];
114 |     uint64_t edid_size;
115 |     LIMINE_PTR(void *) edid;
116 | };
117 | 
118 | struct limine_framebuffer_response {
119 |     uint64_t revision;
120 |     uint64_t framebuffer_count;
121 |     LIMINE_PTR(struct limine_framebuffer **) framebuffers;
122 | };
123 | 
124 | struct limine_framebuffer_request {
125 |     uint64_t id[4];
126 |     uint64_t revision;
127 |     LIMINE_PTR(struct limine_framebuffer_response *) response;
128 | };
129 | 
130 | /* Terminal */
131 | 
132 | #define LIMINE_TERMINAL_REQUEST { LIMINE_COMMON_MAGIC, 0xc8ac59310c2b0844, 0xa68d0c7265d38878 }
133 | 
134 | #define LIMINE_TERMINAL_CB_DEC 10
135 | #define LIMINE_TERMINAL_CB_BELL 20
136 | #define LIMINE_TERMINAL_CB_PRIVATE_ID 30
137 | #define LIMINE_TERMINAL_CB_STATUS_REPORT 40
138 | #define LIMINE_TERMINAL_CB_POS_REPORT 50
139 | #define LIMINE_TERMINAL_CB_KBD_LEDS 60
140 | #define LIMINE_TERMINAL_CB_MODE 70
141 | #define LIMINE_TERMINAL_CB_LINUX 80
142 | 
143 | #define LIMINE_TERMINAL_CTX_SIZE ((uint64_t)(-1))
144 | #define LIMINE_TERMINAL_CTX_SAVE ((uint64_t)(-2))
145 | #define LIMINE_TERMINAL_CTX_RESTORE ((uint64_t)(-3))
146 | #define LIMINE_TERMINAL_FULL_REFRESH ((uint64_t)(-4))
147 | 
148 | struct limine_terminal;
149 | 
150 | typedef void (*limine_terminal_write)(struct limine_terminal *, const char *, uint64_t);
151 | typedef void (*limine_terminal_callback)(struct limine_terminal *, uint64_t, uint64_t, uint64_t, uint64_t);
152 | 
153 | struct limine_terminal {
154 |     uint64_t columns;
155 |     uint64_t rows;
156 |     LIMINE_PTR(struct limine_framebuffer *) framebuffer;
157 | };
158 | 
159 | struct limine_terminal_response {
160 |     uint64_t revision;
161 |     uint64_t terminal_count;
162 |     LIMINE_PTR(struct limine_terminal **) terminals;
163 |     LIMINE_PTR(limine_terminal_write) write;
164 | };
165 | 
166 | struct limine_terminal_request {
167 |     uint64_t id[4];
168 |     uint64_t revision;
169 |     LIMINE_PTR(struct limine_terminal_response *) response;
170 |     LIMINE_PTR(limine_terminal_callback) callback;
171 | };
172 | 
173 | /* 5-level paging */
174 | 
175 | #define LIMINE_5_LEVEL_PAGING_REQUEST { LIMINE_COMMON_MAGIC, 0x94469551da9b3192, 0xebe5e86db7382888 }
176 | 
177 | struct limine_5_level_paging_response {
178 |     uint64_t revision;
179 | };
180 | 
181 | struct limine_5_level_paging_request {
182 |     uint64_t id[4];
183 |     uint64_t revision;
184 |     LIMINE_PTR(struct limine_5_level_paging_response *) response;
185 | };
186 | 
187 | /* SMP */
188 | 
189 | #define LIMINE_SMP_REQUEST { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
190 | 
191 | struct limine_smp_info;
192 | 
193 | typedef void (*limine_goto_address)(struct limine_smp_info *);
194 | 
195 | #if defined (__x86_64__) || defined (__i386__)
196 | 
197 | #define LIMINE_SMP_X2APIC (1 << 0)
198 | 
199 | struct limine_smp_info {
200 |     uint32_t processor_id;
201 |     uint32_t lapic_id;
202 |     uint64_t reserved;
203 |     LIMINE_PTR(limine_goto_address) goto_address;
204 |     uint64_t extra_argument;
205 | };
206 | 
207 | struct limine_smp_response {
208 |     uint64_t revision;
209 |     uint32_t flags;
210 |     uint32_t bsp_lapic_id;
211 |     uint64_t cpu_count;
212 |     LIMINE_PTR(struct limine_smp_info **) cpus;
213 | };
214 | 
215 | #elif defined (__aarch64__)
216 | 
217 | struct limine_smp_info {
218 |     uint32_t processor_id;
219 |     uint32_t gic_iface_no;
220 |     uint64_t mpidr;
221 |     uint64_t reserved;
222 |     LIMINE_PTR(limine_goto_address) goto_address;
223 |     uint64_t extra_argument;
224 | };
225 | 
226 | struct limine_smp_response {
227 |     uint64_t revision;
228 |     uint32_t flags;
229 |     uint64_t bsp_mpidr;
230 |     uint64_t cpu_count;
231 |     LIMINE_PTR(struct limine_smp_info **) cpus;
232 | };
233 | 
234 | #else
235 | #error Unknown architecture
236 | #endif
237 | 
238 | struct limine_smp_request {
239 |     uint64_t id[4];
240 |     uint64_t revision;
241 |     LIMINE_PTR(struct limine_smp_response *) response;
242 |     uint64_t flags;
243 | };
244 | 
245 | /* Memory map */
246 | 
247 | #define LIMINE_MEMMAP_REQUEST { LIMINE_COMMON_MAGIC, 0x67cf3d9d378a806f, 0xe304acdfc50c3c62 }
248 | 
249 | #define LIMINE_MEMMAP_USABLE                 0
250 | #define LIMINE_MEMMAP_RESERVED               1
251 | #define LIMINE_MEMMAP_ACPI_RECLAIMABLE       2
252 | #define LIMINE_MEMMAP_ACPI_NVS               3
253 | #define LIMINE_MEMMAP_BAD_MEMORY             4
254 | #define LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE 5
255 | #define LIMINE_MEMMAP_KERNEL_AND_MODULES     6
256 | #define LIMINE_MEMMAP_FRAMEBUFFER            7
257 | 
258 | struct limine_memmap_entry {
259 |     uint64_t base;
260 |     uint64_t length;
261 |     uint64_t type;
262 | };
263 | 
264 | struct limine_memmap_response {
265 |     uint64_t revision;
266 |     uint64_t entry_count;
267 |     LIMINE_PTR(struct limine_memmap_entry **) entries;
268 | };
269 | 
270 | struct limine_memmap_request {
271 |     uint64_t id[4];
272 |     uint64_t revision;
273 |     LIMINE_PTR(struct limine_memmap_response *) response;
274 | };
275 | 
276 | /* Entry point */
277 | 
278 | #define LIMINE_ENTRY_POINT_REQUEST { LIMINE_COMMON_MAGIC, 0x13d86c035a1cd3e1, 0x2b0caa89d8f3026a }
279 | 
280 | typedef void (*limine_entry_point)(void);
281 | 
282 | struct limine_entry_point_response {
283 |     uint64_t revision;
284 | };
285 | 
286 | struct limine_entry_point_request {
287 |     uint64_t id[4];
288 |     uint64_t revision;
289 |     LIMINE_PTR(struct limine_entry_point_response *) response;
290 |     LIMINE_PTR(limine_entry_point) entry;
291 | };
292 | 
293 | /* Kernel File */
294 | 
295 | #define LIMINE_KERNEL_FILE_REQUEST { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
296 | 
297 | struct limine_kernel_file_response {
298 |     uint64_t revision;
299 |     LIMINE_PTR(struct limine_file *) kernel_file;
300 | };
301 | 
302 | struct limine_kernel_file_request {
303 |     uint64_t id[4];
304 |     uint64_t revision;
305 |     LIMINE_PTR(struct limine_kernel_file_response *) response;
306 | };
307 | 
308 | /* Module */
309 | 
310 | #define LIMINE_MODULE_REQUEST { LIMINE_COMMON_MAGIC, 0x3e7e279702be32af, 0xca1c4f3bd1280cee }
311 | 
312 | struct limine_module_response {
313 |     uint64_t revision;
314 |     uint64_t module_count;
315 |     LIMINE_PTR(struct limine_file **) modules;
316 | };
317 | 
318 | struct limine_module_request {
319 |     uint64_t id[4];
320 |     uint64_t revision;
321 |     LIMINE_PTR(struct limine_module_response *) response;
322 | };
323 | 
324 | /* RSDP */
325 | 
326 | #define LIMINE_RSDP_REQUEST { LIMINE_COMMON_MAGIC, 0xc5e77b6b397e7b43, 0x27637845accdcf3c }
327 | 
328 | struct limine_rsdp_response {
329 |     uint64_t revision;
330 |     LIMINE_PTR(void *) address;
331 | };
332 | 
333 | struct limine_rsdp_request {
334 |     uint64_t id[4];
335 |     uint64_t revision;
336 |     LIMINE_PTR(struct limine_rsdp_response *) response;
337 | };
338 | 
339 | /* SMBIOS */
340 | 
341 | #define LIMINE_SMBIOS_REQUEST { LIMINE_COMMON_MAGIC, 0x9e9046f11e095391, 0xaa4a520fefbde5ee }
342 | 
343 | struct limine_smbios_response {
344 |     uint64_t revision;
345 |     LIMINE_PTR(void *) entry_32;
346 |     LIMINE_PTR(void *) entry_64;
347 | };
348 | 
349 | struct limine_smbios_request {
350 |     uint64_t id[4];
351 |     uint64_t revision;
352 |     LIMINE_PTR(struct limine_smbios_response *) response;
353 | };
354 | 
355 | /* EFI system table */
356 | 
357 | #define LIMINE_EFI_SYSTEM_TABLE_REQUEST { LIMINE_COMMON_MAGIC, 0x5ceba5163eaaf6d6, 0x0a6981610cf65fcc }
358 | 
359 | struct limine_efi_system_table_response {
360 |     uint64_t revision;
361 |     LIMINE_PTR(void *) address;
362 | };
363 | 
364 | struct limine_efi_system_table_request {
365 |     uint64_t id[4];
366 |     uint64_t revision;
367 |     LIMINE_PTR(struct limine_efi_system_table_response *) response;
368 | };
369 | 
370 | /* Boot time */
371 | 
372 | #define LIMINE_BOOT_TIME_REQUEST { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
373 | 
374 | struct limine_boot_time_response {
375 |     uint64_t revision;
376 |     int64_t boot_time;
377 | };
378 | 
379 | struct limine_boot_time_request {
380 |     uint64_t id[4];
381 |     uint64_t revision;
382 |     LIMINE_PTR(struct limine_boot_time_response *) response;
383 | };
384 | 
385 | /* Kernel address */
386 | 
387 | #define LIMINE_KERNEL_ADDRESS_REQUEST { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
388 | 
389 | struct limine_kernel_address_response {
390 |     uint64_t revision;
391 |     uint64_t physical_base;
392 |     uint64_t virtual_base;
393 | };
394 | 
395 | struct limine_kernel_address_request {
396 |     uint64_t id[4];
397 |     uint64_t revision;
398 |     LIMINE_PTR(struct limine_kernel_address_response *) response;
399 | };
400 | 
401 | /* Device Tree Blob */
402 | 
403 | #define LIMINE_DTB_REQUEST { LIMINE_COMMON_MAGIC, 0xb40ddb48fb54bac7, 0x545081493f81ffb7 }
404 | 
405 | struct limine_dtb_response {
406 |     uint64_t revision;
407 |     LIMINE_PTR(void *) dtb_ptr;
408 | };
409 | 
410 | struct limine_dtb_request {
411 |     uint64_t id[4];
412 |     uint64_t revision;
413 |     LIMINE_PTR(struct limine_dtb_response *) response;
414 | };
415 | 
416 | #ifdef __cplusplus
417 | }
418 | #endif
419 | 
420 | #endif
421 | 


--------------------------------------------------------------------------------
/include/limine.h:
--------------------------------------------------------------------------------
  1 | #ifndef _LIMINE_H
  2 | #define _LIMINE_H 1
  3 | 
  4 | #ifdef __cplusplus
  5 | extern "C" {
  6 | #endif
  7 | 
  8 | #include <stdint.h>
  9 | 
 10 | /* Misc */
 11 | 
 12 | #ifdef LIMINE_NO_POINTERS
 13 | #  define LIMINE_PTR(TYPE) uint64_t
 14 | #else
 15 | #  define LIMINE_PTR(TYPE) TYPE
 16 | #endif
 17 | 
 18 | #define LIMINE_COMMON_MAGIC 0xc7b1dd30df4c8b88, 0x0a82e883a194f07b
 19 | 
 20 | struct limine_uuid {
 21 |     uint32_t a;
 22 |     uint16_t b;
 23 |     uint16_t c;
 24 |     uint8_t d[8];
 25 | };
 26 | 
 27 | #define LIMINE_MEDIA_TYPE_GENERIC 0
 28 | #define LIMINE_MEDIA_TYPE_OPTICAL 1
 29 | #define LIMINE_MEDIA_TYPE_TFTP 2
 30 | 
 31 | struct limine_file {
 32 |     uint64_t revision;
 33 |     LIMINE_PTR(void *) address;
 34 |     uint64_t size;
 35 |     LIMINE_PTR(char *) path;
 36 |     LIMINE_PTR(char *) cmdline;
 37 |     uint32_t media_type;
 38 |     uint32_t unused;
 39 |     uint32_t tftp_ip;
 40 |     uint32_t tftp_port;
 41 |     uint32_t partition_index;
 42 |     uint32_t mbr_disk_id;
 43 |     struct limine_uuid gpt_disk_uuid;
 44 |     struct limine_uuid gpt_part_uuid;
 45 |     struct limine_uuid part_uuid;
 46 | };
 47 | 
 48 | /* Boot info */
 49 | 
 50 | #define LIMINE_BOOTLOADER_INFO_REQUEST { LIMINE_COMMON_MAGIC, 0xf55038d8e2a1202f, 0x279426fcf5f59740 }
 51 | 
 52 | struct limine_bootloader_info_response {
 53 |     uint64_t revision;
 54 |     LIMINE_PTR(char *) name;
 55 |     LIMINE_PTR(char *) version;
 56 | };
 57 | 
 58 | struct limine_bootloader_info_request {
 59 |     uint64_t id[4];
 60 |     uint64_t revision;
 61 |     LIMINE_PTR(struct limine_bootloader_info_response *) response;
 62 | };
 63 | 
 64 | /* Stack size */
 65 | 
 66 | #define LIMINE_STACK_SIZE_REQUEST { LIMINE_COMMON_MAGIC, 0x224ef0460a8e8926, 0xe1cb0fc25f46ea3d }
 67 | 
 68 | struct limine_stack_size_response {
 69 |     uint64_t revision;
 70 | };
 71 | 
 72 | struct limine_stack_size_request {
 73 |     uint64_t id[4];
 74 |     uint64_t revision;
 75 |     LIMINE_PTR(struct limine_stack_size_response *) response;
 76 |     uint64_t stack_size;
 77 | };
 78 | 
 79 | /* HHDM */
 80 | 
 81 | #define LIMINE_HHDM_REQUEST { LIMINE_COMMON_MAGIC, 0x48dcf1cb8ad2b852, 0x63984e959a98244b }
 82 | 
 83 | struct limine_hhdm_response {
 84 |     uint64_t revision;
 85 |     uint64_t offset;
 86 | };
 87 | 
 88 | struct limine_hhdm_request {
 89 |     uint64_t id[4];
 90 |     uint64_t revision;
 91 |     LIMINE_PTR(struct limine_hhdm_response *) response;
 92 | };
 93 | 
 94 | /* Framebuffer */
 95 | 
 96 | #define LIMINE_FRAMEBUFFER_REQUEST { LIMINE_COMMON_MAGIC, 0x9d5827dcd881dd75, 0xa3148604f6fab11b }
 97 | 
 98 | #define LIMINE_FRAMEBUFFER_RGB 1
 99 | 
100 | struct limine_framebuffer {
101 |     LIMINE_PTR(void *) address;
102 |     uint64_t width;
103 |     uint64_t height;
104 |     uint64_t pitch;
105 |     uint16_t bpp;
106 |     uint8_t memory_model;
107 |     uint8_t red_mask_size;
108 |     uint8_t red_mask_shift;
109 |     uint8_t green_mask_size;
110 |     uint8_t green_mask_shift;
111 |     uint8_t blue_mask_size;
112 |     uint8_t blue_mask_shift;
113 |     uint8_t unused[7];
114 |     uint64_t edid_size;
115 |     LIMINE_PTR(void *) edid;
116 | };
117 | 
118 | struct limine_framebuffer_response {
119 |     uint64_t revision;
120 |     uint64_t framebuffer_count;
121 |     LIMINE_PTR(struct limine_framebuffer **) framebuffers;
122 | };
123 | 
124 | struct limine_framebuffer_request {
125 |     uint64_t id[4];
126 |     uint64_t revision;
127 |     LIMINE_PTR(struct limine_framebuffer_response *) response;
128 | };
129 | 
130 | /* Terminal */
131 | 
132 | #define LIMINE_TERMINAL_REQUEST { LIMINE_COMMON_MAGIC, 0xc8ac59310c2b0844, 0xa68d0c7265d38878 }
133 | 
134 | #define LIMINE_TERMINAL_CB_DEC 10
135 | #define LIMINE_TERMINAL_CB_BELL 20
136 | #define LIMINE_TERMINAL_CB_PRIVATE_ID 30
137 | #define LIMINE_TERMINAL_CB_STATUS_REPORT 40
138 | #define LIMINE_TERMINAL_CB_POS_REPORT 50
139 | #define LIMINE_TERMINAL_CB_KBD_LEDS 60
140 | #define LIMINE_TERMINAL_CB_MODE 70
141 | #define LIMINE_TERMINAL_CB_LINUX 80
142 | 
143 | #define LIMINE_TERMINAL_CTX_SIZE ((uint64_t)(-1))
144 | #define LIMINE_TERMINAL_CTX_SAVE ((uint64_t)(-2))
145 | #define LIMINE_TERMINAL_CTX_RESTORE ((uint64_t)(-3))
146 | #define LIMINE_TERMINAL_FULL_REFRESH ((uint64_t)(-4))
147 | 
148 | struct limine_terminal;
149 | 
150 | typedef void (*limine_terminal_write)(struct limine_terminal *, const char *, uint64_t);
151 | typedef void (*limine_terminal_callback)(struct limine_terminal *, uint64_t, uint64_t, uint64_t, uint64_t);
152 | 
153 | struct limine_terminal {
154 |     uint64_t columns;
155 |     uint64_t rows;
156 |     LIMINE_PTR(struct limine_framebuffer *) framebuffer;
157 | };
158 | 
159 | struct limine_terminal_response {
160 |     uint64_t revision;
161 |     uint64_t terminal_count;
162 |     LIMINE_PTR(struct limine_terminal **) terminals;
163 |     LIMINE_PTR(limine_terminal_write) write;
164 | };
165 | 
166 | struct limine_terminal_request {
167 |     uint64_t id[4];
168 |     uint64_t revision;
169 |     LIMINE_PTR(struct limine_terminal_response *) response;
170 |     LIMINE_PTR(limine_terminal_callback) callback;
171 | };
172 | 
173 | /* 5-level paging */
174 | 
175 | #define LIMINE_5_LEVEL_PAGING_REQUEST { LIMINE_COMMON_MAGIC, 0x94469551da9b3192, 0xebe5e86db7382888 }
176 | 
177 | struct limine_5_level_paging_response {
178 |     uint64_t revision;
179 | };
180 | 
181 | struct limine_5_level_paging_request {
182 |     uint64_t id[4];
183 |     uint64_t revision;
184 |     LIMINE_PTR(struct limine_5_level_paging_response *) response;
185 | };
186 | 
187 | /* SMP */
188 | 
189 | #define LIMINE_SMP_REQUEST { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
190 | 
191 | struct limine_smp_info;
192 | 
193 | typedef void (*limine_goto_address)(struct limine_smp_info *);
194 | 
195 | #if defined (__x86_64__) || defined (__i386__)
196 | 
197 | #define LIMINE_SMP_X2APIC (1 << 0)
198 | 
199 | struct limine_smp_info {
200 |     uint32_t processor_id;
201 |     uint32_t lapic_id;
202 |     uint64_t reserved;
203 |     LIMINE_PTR(limine_goto_address) goto_address;
204 |     uint64_t extra_argument;
205 | };
206 | 
207 | struct limine_smp_response {
208 |     uint64_t revision;
209 |     uint32_t flags;
210 |     uint32_t bsp_lapic_id;
211 |     uint64_t cpu_count;
212 |     LIMINE_PTR(struct limine_smp_info **) cpus;
213 | };
214 | 
215 | #elif defined (__aarch64__)
216 | 
217 | struct limine_smp_info {
218 |     uint32_t processor_id;
219 |     uint32_t gic_iface_no;
220 |     uint64_t mpidr;
221 |     uint64_t reserved;
222 |     LIMINE_PTR(limine_goto_address) goto_address;
223 |     uint64_t extra_argument;
224 | };
225 | 
226 | struct limine_smp_response {
227 |     uint64_t revision;
228 |     uint32_t flags;
229 |     uint64_t bsp_mpidr;
230 |     uint64_t cpu_count;
231 |     LIMINE_PTR(struct limine_smp_info **) cpus;
232 | };
233 | 
234 | #else
235 | #error Unknown architecture
236 | #endif
237 | 
238 | struct limine_smp_request {
239 |     uint64_t id[4];
240 |     uint64_t revision;
241 |     LIMINE_PTR(struct limine_smp_response *) response;
242 |     uint64_t flags;
243 | };
244 | 
245 | /* Memory map */
246 | 
247 | #define LIMINE_MEMMAP_REQUEST { LIMINE_COMMON_MAGIC, 0x67cf3d9d378a806f, 0xe304acdfc50c3c62 }
248 | 
249 | #define LIMINE_MEMMAP_USABLE                 0
250 | #define LIMINE_MEMMAP_RESERVED               1
251 | #define LIMINE_MEMMAP_ACPI_RECLAIMABLE       2
252 | #define LIMINE_MEMMAP_ACPI_NVS               3
253 | #define LIMINE_MEMMAP_BAD_MEMORY             4
254 | #define LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE 5
255 | #define LIMINE_MEMMAP_KERNEL_AND_MODULES     6
256 | #define LIMINE_MEMMAP_FRAMEBUFFER            7
257 | 
258 | struct limine_memmap_entry {
259 |     uint64_t base;
260 |     uint64_t length;
261 |     uint64_t type;
262 | };
263 | 
264 | struct limine_memmap_response {
265 |     uint64_t revision;
266 |     uint64_t entry_count;
267 |     LIMINE_PTR(struct limine_memmap_entry **) entries;
268 | };
269 | 
270 | struct limine_memmap_request {
271 |     uint64_t id[4];
272 |     uint64_t revision;
273 |     LIMINE_PTR(struct limine_memmap_response *) response;
274 | };
275 | 
276 | /* Entry point */
277 | 
278 | #define LIMINE_ENTRY_POINT_REQUEST { LIMINE_COMMON_MAGIC, 0x13d86c035a1cd3e1, 0x2b0caa89d8f3026a }
279 | 
280 | typedef void (*limine_entry_point)(void);
281 | 
282 | struct limine_entry_point_response {
283 |     uint64_t revision;
284 | };
285 | 
286 | struct limine_entry_point_request {
287 |     uint64_t id[4];
288 |     uint64_t revision;
289 |     LIMINE_PTR(struct limine_entry_point_response *) response;
290 |     LIMINE_PTR(limine_entry_point) entry;
291 | };
292 | 
293 | /* Kernel File */
294 | 
295 | #define LIMINE_KERNEL_FILE_REQUEST { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
296 | 
297 | struct limine_kernel_file_response {
298 |     uint64_t revision;
299 |     LIMINE_PTR(struct limine_file *) kernel_file;
300 | };
301 | 
302 | struct limine_kernel_file_request {
303 |     uint64_t id[4];
304 |     uint64_t revision;
305 |     LIMINE_PTR(struct limine_kernel_file_response *) response;
306 | };
307 | 
308 | /* Module */
309 | 
310 | #define LIMINE_MODULE_REQUEST { LIMINE_COMMON_MAGIC, 0x3e7e279702be32af, 0xca1c4f3bd1280cee }
311 | 
312 | struct limine_module_response {
313 |     uint64_t revision;
314 |     uint64_t module_count;
315 |     LIMINE_PTR(struct limine_file **) modules;
316 | };
317 | 
318 | struct limine_module_request {
319 |     uint64_t id[4];
320 |     uint64_t revision;
321 |     LIMINE_PTR(struct limine_module_response *) response;
322 | };
323 | 
324 | /* RSDP */
325 | 
326 | #define LIMINE_RSDP_REQUEST { LIMINE_COMMON_MAGIC, 0xc5e77b6b397e7b43, 0x27637845accdcf3c }
327 | 
328 | struct limine_rsdp_response {
329 |     uint64_t revision;
330 |     LIMINE_PTR(void *) address;
331 | };
332 | 
333 | struct limine_rsdp_request {
334 |     uint64_t id[4];
335 |     uint64_t revision;
336 |     LIMINE_PTR(struct limine_rsdp_response *) response;
337 | };
338 | 
339 | /* SMBIOS */
340 | 
341 | #define LIMINE_SMBIOS_REQUEST { LIMINE_COMMON_MAGIC, 0x9e9046f11e095391, 0xaa4a520fefbde5ee }
342 | 
343 | struct limine_smbios_response {
344 |     uint64_t revision;
345 |     LIMINE_PTR(void *) entry_32;
346 |     LIMINE_PTR(void *) entry_64;
347 | };
348 | 
349 | struct limine_smbios_request {
350 |     uint64_t id[4];
351 |     uint64_t revision;
352 |     LIMINE_PTR(struct limine_smbios_response *) response;
353 | };
354 | 
355 | /* EFI system table */
356 | 
357 | #define LIMINE_EFI_SYSTEM_TABLE_REQUEST { LIMINE_COMMON_MAGIC, 0x5ceba5163eaaf6d6, 0x0a6981610cf65fcc }
358 | 
359 | struct limine_efi_system_table_response {
360 |     uint64_t revision;
361 |     LIMINE_PTR(void *) address;
362 | };
363 | 
364 | struct limine_efi_system_table_request {
365 |     uint64_t id[4];
366 |     uint64_t revision;
367 |     LIMINE_PTR(struct limine_efi_system_table_response *) response;
368 | };
369 | 
370 | /* Boot time */
371 | 
372 | #define LIMINE_BOOT_TIME_REQUEST { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
373 | 
374 | struct limine_boot_time_response {
375 |     uint64_t revision;
376 |     int64_t boot_time;
377 | };
378 | 
379 | struct limine_boot_time_request {
380 |     uint64_t id[4];
381 |     uint64_t revision;
382 |     LIMINE_PTR(struct limine_boot_time_response *) response;
383 | };
384 | 
385 | /* Kernel address */
386 | 
387 | #define LIMINE_KERNEL_ADDRESS_REQUEST { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
388 | 
389 | struct limine_kernel_address_response {
390 |     uint64_t revision;
391 |     uint64_t physical_base;
392 |     uint64_t virtual_base;
393 | };
394 | 
395 | struct limine_kernel_address_request {
396 |     uint64_t id[4];
397 |     uint64_t revision;
398 |     LIMINE_PTR(struct limine_kernel_address_response *) response;
399 | };
400 | 
401 | /* Device Tree Blob */
402 | 
403 | #define LIMINE_DTB_REQUEST { LIMINE_COMMON_MAGIC, 0xb40ddb48fb54bac7, 0x545081493f81ffb7 }
404 | 
405 | struct limine_dtb_response {
406 |     uint64_t revision;
407 |     LIMINE_PTR(void *) dtb_ptr;
408 | };
409 | 
410 | struct limine_dtb_request {
411 |     uint64_t id[4];
412 |     uint64_t revision;
413 |     LIMINE_PTR(struct limine_dtb_response *) response;
414 | };
415 | 
416 | #ifdef __cplusplus
417 | }
418 | #endif
419 | 
420 | #endif
421 | 


--------------------------------------------------------------------------------
/kernel/video/printf.c:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * @author (c) Eyal Rozenberg <eyalroz1@gmx.com>
   3 |  *             2021-2022, Haifa, Palestine/Israel
   4 |  * @author (c) Marco Paland (info@paland.com)
   5 |  *             2014-2019, PALANDesign Hannover, Germany
   6 |  *
   7 |  * @note Others have made smaller contributions to this file: see the
   8 |  * contributors page at https://github.com/eyalroz/printf/graphs/contributors
   9 |  * or ask one of the authors. The original code for exponential specifiers was
  10 |  * contributed by Martijn Jasperse <m.jasperse@gmail.com>.
  11 |  *
  12 |  * @brief Small stand-alone implementation of the printf family of functions
  13 |  * (`(v)printf`, `(v)s(n)printf` etc., geared towards use on embedded systems with
  14 |  * a very limited resources.
  15 |  *
  16 |  * @note the implementations are thread-safe; re-entrant; use no functions from
  17 |  * the standard library; and do not dynamically allocate any memory.
  18 |  *
  19 |  * @license The MIT License (MIT)
  20 |  *
  21 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  22 |  * of this software and associated documentation files (the "Software"), to deal
  23 |  * in the Software without restriction, including without limitation the rights
  24 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  25 |  * copies of the Software, and to permit persons to whom the Software is
  26 |  * furnished to do so, subject to the following conditions:
  27 |  *
  28 |  * The above copyright notice and this permission notice shall be included in
  29 |  * all copies or substantial portions of the Software.
  30 |  *
  31 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  32 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  33 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  34 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  35 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  36 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  37 |  * THE SOFTWARE.
  38 |  */
  39 | /*
  40 | 	NOTE: This code has been modified from the original.
  41 | 	For the original file, please see https://github.com/eyalroz/printf/blob/master/src/printf/printf.c
  42 | */
  43 | #include <stdint.h>
  44 | #include <limits.h>
  45 | #include <stdbool.h>
  46 | 
  47 | #include "printf.h"
  48 | // This is unnecessary in C99, since compound initializers can be used,
  49 | // but:
  50 | // 1. Some compilers are finicky about this;
  51 | // 2. Some people may want to convert this to C89;
  52 | // 3. If you try to use it as C++, only C++20 supports compound literals
  53 | // static inline double_with_bit_access getBitAccess(double x) {
  54 | 	// double_with_bit_access dwba;
  55 | 	// dwba.F = x;
  56 | 	// return dwba;
  57 | // }
  58 | 
  59 | // static inline int getSignBit(double x) {
  60 | 	// The sign is stored in the highest bit
  61 | 	// return (int) (getBitAccess(x).U >> (DOUBLE_SIZE_IN_BITS - 1));
  62 | // }
  63 | 
  64 | // static inline int getExp2(double_with_bit_access x) {
  65 | 	// The exponent in an IEEE-754 floating-point number occupies a contiguous
  66 | 	// sequence of bits (e.g. 52..62 for 64-bit doubles), but with a non-trivial representation: An
  67 | 	// unsigned offset from some negative value (with the extremal offset values reserved for
  68 | 	// special use).
  69 | 	// return (int)((x.U >> DOUBLE_STORED_MANTISSA_BITS ) & DOUBLE_EXPONENT_MASK) - DOUBLE_BASE_EXPONENT;
  70 | // }
  71 | // Note: This function currently assumes it is not passed a '\0' c,
  72 | // or alternatively, that '\0' can be passed to the function in the output
  73 | // gadget. The former assumption holds within the printf library. It also
  74 | // assumes that the output gadget has been properly initialized.
  75 | static inline void putcharViaGadget(outputGadget_t* gadget, char c) {
  76 | 	printfSize_t write_pos = gadget->pos++;
  77 | 		// We're _always_ increasing pos, so as to count how may characters
  78 | 		// _would_ have been written if not for the max_chars limitation
  79 | 	if (write_pos >= gadget->max_chars) {
  80 | 		return;
  81 | 	}
  82 | 	if (gadget->function != NULL) {
  83 | 		// No check for c == '\0' .
  84 | 		gadget->function(c, gadget->extra_function_arg);
  85 | 	}
  86 | 	else {
  87 | 		// it must be the case that gadget->buffer != NULL , due to the constraint
  88 | 		// on outputGadget_t ; and note we're relying on write_pos being non-negative.
  89 | 		gadget->buffer[write_pos] = c;
  90 | 	}
  91 | }
  92 | 
  93 | // Possibly-write the string-terminating '\0' character
  94 | static inline void appendTermWithGadget(outputGadget_t* gadget) {
  95 | 	if (gadget->function != NULL || gadget->max_chars == 0) {
  96 | 		return;
  97 | 	}
  98 | 	if (gadget->buffer == NULL) {
  99 | 		return;
 100 | 	}
 101 | 	printfSize_t null_char_pos = gadget->pos < gadget->max_chars ? gadget->pos : gadget->max_chars - 1;
 102 | 	gadget->buffer[null_char_pos] = '\0';
 103 | }
 104 | 
 105 | // We can't use putchar as is, since our output gadget
 106 | // only takes pointers to functions with an extra argument
 107 | static inline void putcharWrapper(char c, void* unused) {
 108 | 	(void) unused;
 109 | 	putchar(c);
 110 | }
 111 | 
 112 | static inline outputGadget_t discardingGadget(void) {
 113 | 	outputGadget_t gadget;
 114 | 	gadget.function = NULL;
 115 | 	gadget.extra_function_arg = NULL;
 116 | 	gadget.buffer = NULL;
 117 | 	gadget.pos = 0;
 118 | 	gadget.max_chars = 0;
 119 | 	return gadget;
 120 | }
 121 | 
 122 | static inline outputGadget_t bufferGadget(char* buffer, size_t size) {
 123 | 	printfSize_t usable_buffer_size = (size > PRINTF_MAX_POSSIBLE_BUFFER_SIZE) ?
 124 | 		PRINTF_MAX_POSSIBLE_BUFFER_SIZE : (printfSize_t) size;
 125 | 	outputGadget_t result = discardingGadget();
 126 | 	if (buffer != NULL) {
 127 | 		result.buffer = buffer;
 128 | 		result.max_chars = usable_buffer_size;
 129 | 	}
 130 | 	return result;
 131 | }
 132 | 
 133 | static inline outputGadget_t functionGadget(void (*function)(char, void*), void* extraArg) {
 134 | 	outputGadget_t result = discardingGadget();
 135 | 	result.function = function;
 136 | 	result.extra_function_arg = extraArg;
 137 | 	result.max_chars = PRINTF_MAX_POSSIBLE_BUFFER_SIZE;
 138 | 	return result;
 139 | }
 140 | 
 141 | static inline outputGadget_t externPutcharGadget(void) {
 142 | 	return functionGadget(putcharWrapper, NULL);
 143 | }
 144 | 
 145 | 
 146 | // internal ASCII string to printfSize_t conversion
 147 | static printfSize_t atou_(const char** str) {
 148 | 	printfSize_t i = 0U;
 149 | 	while (isdigit(**str)) {
 150 | 		i = i * 10U + (printfSize_t)(*((*str)++) - '0');
 151 | 	}
 152 | 	return i;
 153 | }
 154 | 
 155 | 
 156 | // output the specified string in reverse, taking care of any zero-padding
 157 | static void outRev_(outputGadget_t* output, const char* buf, printfSize_t len, printfSize_t width, printfFlags_t flags) {
 158 | 	const printfSize_t start_pos = output->pos;
 159 | 
 160 | 	// pad spaces up to given width
 161 | 	if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
 162 | 		for (printfSize_t i = len; i < width; i++) {
 163 | 			putcharViaGadget(output, ' ');
 164 | 		}
 165 | 	}
 166 | 
 167 | 	// reverse string
 168 | 	while (len) {
 169 | 		putcharViaGadget(output, buf[--len]);
 170 | 	}
 171 | 
 172 | 	// append pad spaces up to given width
 173 | 	if (flags & FLAGS_LEFT) {
 174 | 		while (output->pos - start_pos < width) {
 175 | 			putcharViaGadget(output, ' ');
 176 | 		}
 177 | 	}
 178 | }
 179 | 
 180 | 
 181 | // Invoked by printInt after the actual number has been printed, performing necessary
 182 | // work on the number's prefix (as the number is initially printed in reverse order)
 183 | static void printIntegerFinalization(outputGadget_t* output, char* buf, printfSize_t len, bool negative, numericBase_t base, printfSize_t precision, printfSize_t width, printfFlags_t flags) {
 184 | 	printfSize_t unpadded_len = len;
 185 | 
 186 | 	// pad with leading zeros
 187 | 	if (!(flags & FLAGS_LEFT)) {
 188 | 		if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
 189 | 			width--;
 190 | 		}
 191 | 		while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_INTEGER_BUFFER_SIZE)) {
 192 | 			buf[len++] = '0';
 193 | 		}
 194 | 	}
 195 | 
 196 | 	while ((len < precision) && (len < PRINTF_INTEGER_BUFFER_SIZE)) {
 197 | 		buf[len++] = '0';
 198 | 	}
 199 | 
 200 | 	if (base == BASE_OCTAL && (len > unpadded_len)) {
 201 | 		// Since we've written some zeros, we've satisfied the alternative format leading space requirement
 202 | 		flags &= ~FLAGS_HASH;
 203 | 	}
 204 | 
 205 | 	// handle hash
 206 | 	if (flags & (FLAGS_HASH | FLAGS_POINTER)) {
 207 | 		if (!(flags & FLAGS_PRECISION) && len && ((len == precision) || (len == width))) {
 208 | 			// Let's take back some padding digits to fit in what will eventually
 209 | 			// be the format-specific prefix
 210 | 			if (unpadded_len < len) {
 211 | 				len--; // This should suffice for BASE_OCTAL
 212 | 			}
 213 | 			if (len && (base == BASE_HEX || base == BASE_BINARY) && (unpadded_len < len)) {
 214 | 				len--; // ... and an extra one for 0x or 0b
 215 | 			}
 216 | 		}
 217 | 		if ((base == BASE_HEX) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_INTEGER_BUFFER_SIZE)) {
 218 | 			buf[len++] = 'x';
 219 | 		}
 220 | 		else if ((base == BASE_HEX) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_INTEGER_BUFFER_SIZE)) {
 221 | 			buf[len++] = 'X';
 222 | 		}
 223 | 		else if ((base == BASE_BINARY) && (len < PRINTF_INTEGER_BUFFER_SIZE)) {
 224 | 			buf[len++] = 'b';
 225 | 		}
 226 | 		if (len < PRINTF_INTEGER_BUFFER_SIZE) {
 227 | 			buf[len++] = '0';
 228 | 		}
 229 | 	}
 230 | 
 231 | 	if (len < PRINTF_INTEGER_BUFFER_SIZE) {
 232 | 		if (negative) {
 233 | 			buf[len++] = '-';
 234 | 		}
 235 | 		else if (flags & FLAGS_PLUS) {
 236 | 			buf[len++] = '+';  // ignore the space if the '+' exists
 237 | 		}
 238 | 		else if (flags & FLAGS_SPACE) {
 239 | 			buf[len++] = ' ';
 240 | 		}
 241 | 	}
 242 | 
 243 | 	outRev_(output, buf, len, width, flags);
 244 | }
 245 | 
 246 | // An internal itoa-like function
 247 | static void printInt(outputGadget_t* output, printfUnsignedValue_t value, bool negative, numericBase_t base, printfSize_t precision, printfSize_t width, printfFlags_t flags) {
 248 | 	char buf[PRINTF_INTEGER_BUFFER_SIZE];
 249 | 	printfSize_t len = 0U;
 250 | 
 251 | 	if (!value) {
 252 | 		if ( !(flags & FLAGS_PRECISION) ) {
 253 | 			buf[len++] = '0';
 254 | 			flags &= ~FLAGS_HASH;
 255 | 			// We drop this flag this since either the alternative and regular modes of the specifier
 256 | 			// don't differ on 0 values, or (in the case of octal) we've already provided the special
 257 | 			// handling for this mode.
 258 | 		}
 259 | 		else if (base == BASE_HEX) {
 260 | 			flags &= ~FLAGS_HASH;
 261 | 			// We drop this flag this since either the alternative and regular modes of the specifier
 262 | 			// don't differ on 0 values
 263 | 		}
 264 | 	}
 265 | 	else {
 266 | 		while (value && (len < PRINTF_INTEGER_BUFFER_SIZE)) {
 267 | 			const char digit = (char)(value % base);
 268 | 			buf[len++] = (char)(digit < 10 ? '0' + digit : 'A' + digit - 10);
 269 | 			value /= base;
 270 | 		}
 271 | 	}
 272 | 
 273 | 	printIntegerFinalization(output, buf, len, negative, base, precision, width, flags);
 274 | }
 275 | 
 276 | #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS)
 277 | 
 278 | // Stores a fixed-precision representation of a double relative
 279 | // to a fixed precision (which cannot be determined by examining this structure)
 280 | typedef struct {
 281 | 	int_fast64_t integral;
 282 | 	int_fast64_t fractional;
 283 | 	// ... truncation of the actual fractional part of the double value, scaled
 284 | 	// by the precision value
 285 | 	bool is_negative;
 286 | } doubleComponents_t;
 287 | 
 288 | #define NUM_DECIMAL_DIGITS_IN_INT64_T 18
 289 | #define PRINTF_MAX_PRECOMPUTED_POWER_OF_10  NUM_DECIMAL_DIGITS_IN_INT64_T
 290 | static const double powOf10[NUM_DECIMAL_DIGITS_IN_INT64_T] = {
 291 | 	1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08,
 292 | 	1e09, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17
 293 | };
 294 | 
 295 | #define PRINTF_MAX_SUPPORTED_PRECISION NUM_DECIMAL_DIGITS_IN_INT64_T - 1
 296 | 
 297 | 
 298 | // Break up a double number - which is known to be a finite non-negative number -
 299 | // into its base-10 parts: integral - before the decimal point, and fractional - after it.
 300 | // Taken the precision into account, but does not change it even internally.
 301 | static doubleComponents_t getComponents(double number, printfSize_t precision) {
 302 | 	doubleComponents_t number_;
 303 | 	number_.is_negative = getSignBit(number);
 304 | 	double absNumber = (number_.is_negative) ? -number : number;
 305 | 	number_.integral = (int_fast64_t)absNumber;
 306 | 	double remainder = (absNumber - (double) number_.integral) * powOf10[precision];
 307 | 	number_.fractional = (int_fast64_t)remainder;
 308 | 
 309 | 	remainder -= (double) number_.fractional;
 310 | 
 311 | 	if (remainder > 0.5) {
 312 | 		++number_.fractional;
 313 | 		// handle rollover, e.g. case 0.99 with precision 1 is 1.0
 314 | 		if ((double) number_.fractional >= powOf10[precision]) {
 315 | 			number_.fractional = 0;
 316 | 			++number_.integral;
 317 | 		}
 318 | 	}
 319 | 	else if ((remainder == 0.5) && ((number_.fractional == 0U) || (number_.fractional & 1U))) {
 320 | 		// if halfway, round up if odd OR if last digit is 0
 321 | 		++number_.fractional;
 322 | 	}
 323 | 
 324 | 	if (precision == 0U) {
 325 | 		remainder = absNumber - (double) number_.integral;
 326 | 		if ((!(remainder < 0.5) || (remainder > 0.5)) && (number_.integral & 1)) {
 327 | 			// exactly 0.5 and ODD, then round up
 328 | 			// 1.5 -> 2, but 2.5 -> 2
 329 | 			++number_.integral;
 330 | 		}
 331 | 	}
 332 | 	return number_;
 333 | }
 334 | 
 335 | #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 336 | typedef struct {
 337 | 	double rawFactor;
 338 | 	bool multiply; // if true, need to multiply by rawFactor; otherwise need to divide by it
 339 | } scalingFactor_t;
 340 | 
 341 | static double applyScaling(double num, scalingFactor_t normalization) {
 342 | 	return normalization.multiply ? num * normalization.rawFactor : num / normalization.rawFactor;
 343 | }
 344 | 
 345 | static double unapplyScaling(double normalized, scalingFactor_t normalization) {
 346 | 	return normalization.multiply ? normalized / normalization.rawFactor : normalized * normalization.rawFactor;
 347 | }
 348 | 
 349 | static scalingFactor_t updateNormalization(scalingFactor_t sf, double extraMultiFactor) {
 350 | 	scalingFactor_t result;
 351 | 	if (sf.multiply) {
 352 | 		result.multiply = true;
 353 | 		result.rawFactor = sf.rawFactor * extraMultiFactor;
 354 | 	}
 355 | 	else {
 356 | 		int factorExp2 = getExp2(getBitAccess(sf.rawFactor));
 357 | 		int extraFactorExp2 = getExp2(getBitAccess(extraMultiFactor));
 358 | 
 359 | 		// Divide the larger-exponent raw rawFactor by the smaller
 360 | 		if (PRINTF_ABS(factorExp2) > PRINTF_ABS(extraFactorExp2)) {
 361 | 			result.multiply = false;
 362 | 			result.rawFactor = sf.rawFactor / extraMultiFactor;
 363 | 		}
 364 | 		else {
 365 | 			result.multiply = true;
 366 | 			result.rawFactor = extraMultiFactor / sf.rawFactor;
 367 | 		}
 368 | 	}
 369 | 	return result;
 370 | }
 371 | 
 372 | static doubleComponents_t getNormalizedComponents(bool negative, printfSize_t precision, double nonNormalized, scalingFactor_t normalization, int flooredExp10) {
 373 | 	doubleComponents_t components;
 374 | 	components.is_negative = negative;
 375 | 	double scaled = applyScaling(nonNormalized, normalization);
 376 | 
 377 | 	bool close_to_representation_extremum = ( (-flooredExp10 + (int) precision) >= DBL_MAX_10_EXP - 1 );
 378 | 	if (close_to_representation_extremum) {
 379 | 		// We can't have a normalization factor which also accounts for the precision, i.e. moves
 380 | 		// some decimal digits into the mantissa, since it's unrepresentable, or nearly unrepresentable.
 381 | 		// So, we'll give up early on getting extra precision...
 382 | 		return getComponents(negative ? -scaled : scaled, precision);
 383 | 	}
 384 | 	components.integral = (int_fast64_t) scaled;
 385 | 	double remainder = nonNormalized - unapplyScaling((double) components.integral, normalization);
 386 | 	double precPowerOf10 = powOf10[precision];
 387 | 	scalingFactor_t accountForPrecision = updateNormalization(normalization, precPowerOf10);
 388 | 	double scaled_remainder = applyScaling(remainder, accountForPrecision);
 389 | 	double rounding_threshold = 0.5;
 390 | 
 391 | 	components.fractional = (int_fast64_t) scaled_remainder; // when precision == 0, the assigned value should be 0
 392 | 	scaled_remainder -= (double) components.fractional; //when precision == 0, this will not change scaled_remainder
 393 | 
 394 | 	components.fractional += (scaled_remainder >= rounding_threshold);
 395 | 	if (scaled_remainder == rounding_threshold) {
 396 | 		// banker's rounding: Round towards the even number (making the mean error 0)
 397 | 		components.fractional &= ~((int_fast64_t) 0x1);
 398 | 	}
 399 | 	// handle rollover, e.g. the case of 0.99 with precision 1 becoming (0,100),
 400 | 	// and must then be corrected into (1, 0).
 401 | 	// Note: for precision = 0, this will "translate" the rounding effect from
 402 | 	// the fractional part to the integral part where it should actually be
 403 | 	// felt (as precPowerOf10 is 1)
 404 | 	if ((double) components.fractional >= precPowerOf10) {
 405 | 		components.fractional = 0;
 406 | 		++components.integral;
 407 | 	}
 408 | 	return components;
 409 | }
 410 | #endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 411 | 
 412 | static void printBrokenDec(
 413 | 	doubleComponents_t number_, outputGadget_t* output, printfSize_t precision,
 414 | 	printfSize_t width, printfFlags_t flags, char *buf, printfSize_t len) {
 415 | 	if (precision != 0U) {
 416 | 		// do fractional part, as an unsigned number
 417 | 
 418 | 		printfSize_t count = precision;
 419 | 
 420 | 		// %g/%G mandates we skip the trailing 0 digits...
 421 | 		if ((flags & FLAGS_ADAPT_EXP) && !(flags & FLAGS_HASH) && (number_.fractional > 0)) {
 422 | 			while(true) {
 423 | 				int_fast64_t digit = number_.fractional % 10U;
 424 | 				if (digit != 0) {
 425 | 					break;
 426 | 				}
 427 | 				--count;
 428 | 				number_.fractional /= 10U;
 429 | 
 430 | 			}
 431 | 			// ... and even the decimal point if there are no
 432 | 			// non-zero fractional part digits (see below)
 433 | 		}
 434 | 
 435 | 		if (number_.fractional > 0 || !(flags & FLAGS_ADAPT_EXP) || (flags & FLAGS_HASH) ) {
 436 | 			while (len < PRINTF_DECIMAL_BUFFER_SIZE) {
 437 | 				--count;
 438 | 				buf[len++] = (char)('0' + number_.fractional % 10U);
 439 | 				if (!(number_.fractional /= 10U)) {
 440 | 					break;
 441 | 				}
 442 | 			}
 443 | 			// add extra 0s
 444 | 			while ((len < PRINTF_DECIMAL_BUFFER_SIZE) && (count > 0U)) {
 445 | 				buf[len++] = '0';
 446 | 				--count;
 447 | 			}
 448 | 			if (len < PRINTF_DECIMAL_BUFFER_SIZE) {
 449 | 				buf[len++] = '.';
 450 | 			}
 451 | 		}
 452 | 	}
 453 | 	else {
 454 | 		if ((flags & FLAGS_HASH) && (len < PRINTF_DECIMAL_BUFFER_SIZE)) {
 455 | 			buf[len++] = '.';
 456 | 		}
 457 | 	}
 458 | 
 459 | 	// Write the integer part of the number (it comes after the fractional
 460 | 	// since the character order is reversed)
 461 | 	while (len < PRINTF_DECIMAL_BUFFER_SIZE) {
 462 | 		buf[len++] = (char)('0' + (number_.integral % 10));
 463 | 		if (!(number_.integral /= 10)) {
 464 | 			break;
 465 | 		}
 466 | 	}
 467 | 
 468 | 	// pad leading zeros
 469 | 	if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
 470 | 		if (width && (number_.is_negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
 471 | 			width--;
 472 | 		}
 473 | 		while ((len < width) && (len < PRINTF_DECIMAL_BUFFER_SIZE)) {
 474 | 			buf[len++] = '0';
 475 | 		}
 476 | 	}
 477 | 
 478 | 	if (len < PRINTF_DECIMAL_BUFFER_SIZE) {
 479 | 		if (number_.is_negative) {
 480 | 			buf[len++] = '-';
 481 | 		}
 482 | 		else if (flags & FLAGS_PLUS) {
 483 | 			buf[len++] = '+';  // ignore the space if the '+' exists
 484 | 		}
 485 | 		else if (flags & FLAGS_SPACE) {
 486 | 			buf[len++] = ' ';
 487 | 		}
 488 | 	}
 489 | 
 490 | 	outRev_(output, buf, len, width, flags);
 491 | }
 492 | 
 493 | // internal ftoa for fixed decimal floating point
 494 | static void printDecimal(outputGadget_t* output, double number, printfSize_t precision, printfSize_t width, printfFlags_t flags, char* buf, printfSize_t len) {
 495 | 	doubleComponents_t value_ = getComponents(number, precision);
 496 | 	printBrokenDec(value_, output, precision, width, flags, buf, len);
 497 | }
 498 | 
 499 | #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 500 | 
 501 | // A floor function - but one which only works for numbers whose
 502 | // floor value is representable by an int.
 503 | static int bastardizedFloor(double x) {
 504 | 	if (x >= 0) { return (int) x; }
 505 | 	int n = (int) x;
 506 | 	return ( ((double) n) == x ) ? n : n-1;
 507 | }
 508 | 
 509 | // Computes the base-10 logarithm of the input number - which must be an actual
 510 | // positive number (not infinity or NaN, nor a sub-normal)
 511 | static double log10OfPositive(double positiveNum) {
 512 | 	// The implementation follows David Gay (https://www.ampl.com/netlib/fp/dtoa.c).
 513 | 	//
 514 | 	// Since log_10 ( M * 2^x ) = log_10(M) + x , we can separate the components of
 515 | 	// our input number, and need only solve log_10(M) for M between 1 and 2 (as
 516 | 	// the base-2 mantissa is always 1-point-something). In that limited range, a
 517 | 	// Taylor series expansion of log10(x) should serve us well enough; and we'll
 518 | 	// take the mid-point, 1.5, as the point of expansion.
 519 | 
 520 | 	double_with_bit_access dwba = getBitAccess(positiveNum);
 521 | 	// based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
 522 | 	int exp2 = getExp2(dwba);
 523 | 	// drop the exponent, so dwba.F comes into the range [1,2)
 524 | 	dwba.U = (dwba.U & (((double_uint_t) (1) << DOUBLE_STORED_MANTISSA_BITS) - 1U)) |
 525 | 					 ((double_uint_t) DOUBLE_BASE_EXPONENT << DOUBLE_STORED_MANTISSA_BITS);
 526 | 	double z = (dwba.F - 1.5);
 527 | 	return (
 528 | 		// Taylor expansion around 1.5:
 529 | 		0.1760912590556812420           // Expansion term 0: ln(1.5)            / ln(10)
 530 | 		+ z     * 0.2895296546021678851 // Expansion term 1: (M - 1.5)   * 2/3  / ln(10)
 531 | #if PRINTF_LOG10_TAYLOR_TERMS > 2
 532 | 		- z*z   * 0.0965098848673892950 // Expansion term 2: (M - 1.5)^2 * 2/9  / ln(10)
 533 | #if PRINTF_LOG10_TAYLOR_TERMS > 3
 534 | 		+ z*z*z * 0.0428932821632841311 // Expansion term 2: (M - 1.5)^3 * 8/81 / ln(10)
 535 | #endif
 536 | #endif
 537 | 		// exact log_2 of the exponent x, with logarithm base change
 538 | 		+ exp2 * 0.30102999566398119521 // = exp2 * log_10(2) = exp2 * ln(2)/ln(10)
 539 | 	);
 540 | }
 541 | 
 542 | 
 543 | static double pow10Ofint(int flooredExp10) {
 544 | 	// A crude hack for avoiding undesired behavior with barely-normal or slightly-subnormal values.
 545 | 	if (flooredExp10 == DOUBLE_MAX_SUBNORMAL_EXPONENT_OF_10) {
 546 | 		return DOUBLE_MAX_SUBNORMAL_POWER_OF_10;
 547 | 	}
 548 | 	// Compute 10^(flooredExp10) but (try to) make sure that doesn't overflow
 549 | 	double_with_bit_access dwba;
 550 | 	int exp2 = bastardizedFloor(flooredExp10 * 3.321928094887362 + 0.5);
 551 | 	const double z  = flooredExp10 * 2.302585092994046 - exp2 * 0.6931471805599453;
 552 | 	const double z2 = z * z;
 553 | 	dwba.U = ((double_uint_t)(exp2) + DOUBLE_BASE_EXPONENT) << DOUBLE_STORED_MANTISSA_BITS;
 554 | 	// compute exp(z) using continued fractions,
 555 | 	// see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
 556 | 	dwba.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
 557 | 	return dwba.F;
 558 | }
 559 | 
 560 | static void printExpontNum(outputGadget_t* output, double number, printfSize_t precision, printfSize_t width, printfFlags_t flags, char* buf, printfSize_t len) {
 561 | 	const bool negative = getSignBit(number);
 562 | 	// This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it
 563 | 	double absNumber =  negative ? -number : number;
 564 | 
 565 | 	int flooredExp10;
 566 | 	bool absExp10CoveredByPowTbl;
 567 | 	scalingFactor_t normalization;
 568 | 
 569 | 
 570 | 	// Determine the decimal exponent
 571 | 	if (absNumber == 0.0) {
 572 | 		// TODO: This is a special-case for 0.0 (and -0.0); but proper handling is required for denormals more generally.
 573 | 		flooredExp10 = 0; // ... and no need to set a normalization factor or check the powers table
 574 | 	}
 575 | 	else  {
 576 | 		double exp10 = log10OfPositive(absNumber);
 577 | 		flooredExp10 = bastardizedFloor(exp10);
 578 | 		double p10 = pow10Ofint(flooredExp10);
 579 | 		// correct for rounding errors
 580 | 		if (absNumber < p10) {
 581 | 			flooredExp10--;
 582 | 			p10 /= 10;
 583 | 		}
 584 | 		absExp10CoveredByPowTbl = PRINTF_ABS(flooredExp10) < PRINTF_MAX_PRECOMPUTED_POWER_OF_10;
 585 | 		normalization.rawFactor = absExp10CoveredByPowTbl ? powOf10[PRINTF_ABS(flooredExp10)] : p10;
 586 | 	}
 587 | 
 588 | 	// We now begin accounting for the widths of the two parts of our printed field:
 589 | 	// the decimal part after decimal exponent extraction, and the base-10 exponent part.
 590 | 	// For both of these, the value of 0 has a special meaning, but not the same one:
 591 | 	// a 0 exponent-part width means "don't print the exponent"; a 0 decimal-part width
 592 | 	// means "use as many characters as necessary".
 593 | 
 594 | 	bool fallbackToDecOnly = false;
 595 | 	if (flags & FLAGS_ADAPT_EXP) {
 596 | 		int required_significant_digits = (precision == 0) ? 1 : (int) precision;
 597 | 		// Should we want to fall-back to "%f" mode, and only print the decimal part?
 598 | 		fallbackToDecOnly = (flooredExp10 >= -4 && flooredExp10 < required_significant_digits);
 599 | 		// Now, let's adjust the precision
 600 | 		// This also decided how we adjust the precision value - as in "%g" mode,
 601 | 		// "precision" is the number of _significant digits_, and this is when we "translate"
 602 | 		// the precision value to an actual number of decimal digits.
 603 | 		int precision_ = fallbackToDecOnly ?
 604 | 										 (int) precision - 1 - flooredExp10 :
 605 | 				(int) precision - 1; // the presence of the exponent ensures only one significant digit comes before the decimal point
 606 | 		precision = (precision_ > 0 ? (unsigned) precision_ : 0U);
 607 | 		flags |= FLAGS_PRECISION;   // make sure printBrokenDec respects our choice above
 608 | 	}
 609 | 
 610 | 	normalization.multiply = (flooredExp10 < 0 && absExp10CoveredByPowTbl);
 611 | 	bool should_skip_normalization = (fallbackToDecOnly || flooredExp10 == 0);
 612 | 	doubleComponents_t decimalPartComponents =
 613 | 		should_skip_normalization ?
 614 | 		getComponents(negative ? -absNumber : absNumber, precision) :
 615 | 		getNormalizedComponents(negative, precision, absNumber, normalization, flooredExp10);
 616 | 
 617 | 	// Account for roll-over, e.g. rounding from 9.99 to 100.0 - which effects
 618 | 	// the exponent and may require additional tweaking of the parts
 619 | 	if (fallbackToDecOnly) {
 620 | 		if ((flags & FLAGS_ADAPT_EXP) && flooredExp10 >= -1 && decimalPartComponents.integral == powOf10[flooredExp10 + 1]) {
 621 | 			flooredExp10++; // Not strictly necessary, since floored_exp10 is no longer really used
 622 | 			precision--;
 623 | 			// ... and it should already be the case that decimalPartComponents.fractional == 0
 624 | 		}
 625 | 		// TODO: What about rollover strictly within the fractional part?
 626 | 	}
 627 | 	else {
 628 | 		if (decimalPartComponents.integral >= 10) {
 629 | 			flooredExp10++;
 630 | 			decimalPartComponents.integral = 1;
 631 | 			decimalPartComponents.fractional = 0;
 632 | 		}
 633 | 	}
 634 | 
 635 | 	// the floored_exp10 format is "E%+03d" and largest possible floored_exp10 value for a 64-bit double
 636 | 	// is "307" (for 2^1023), so we set aside 4-5 characters overall
 637 | 	printfSize_t exp10PartWidth = fallbackToDecOnly ? 0U : (PRINTF_ABS(flooredExp10) < 100) ? 4U : 5U;
 638 | 
 639 | 	printfSize_t decimalPartWidth =
 640 | 		((flags & FLAGS_LEFT) && exp10PartWidth) ?
 641 | 			// We're padding on the right, so the width constraint is the exponent part's
 642 | 			// problem, not the decimal part's, so we'll use as many characters as we need:
 643 | 			0U :
 644 | 			// We're padding on the left; so the width constraint is the decimal part's
 645 | 			// problem. Well, can both the decimal part and the exponent part fit within our overall width?
 646 | 			((width > exp10PartWidth) ?
 647 | 				// Yes, so we limit our decimal part's width.
 648 | 				// (Note this is trivially valid even if we've fallen back to "%f" mode)
 649 | 				width - exp10PartWidth :
 650 | 				// No; we just give up on any restriction on the decimal part and use as many
 651 | 				// characters as we need
 652 | 				0U);
 653 | 
 654 | 	const printfSize_t printentExpStartPos = output->pos;
 655 | 	printBrokenDec(decimalPartComponents, output, precision, decimalPartWidth, flags, buf, len);
 656 | 
 657 | 	if (! fallbackToDecOnly) {
 658 | 		putcharViaGadget(output, (flags & FLAGS_UPPERCASE) ? 'E' : 'e');
 659 | 		printInt(output,
 660 | 									ABS_FOR_PRINTING(flooredExp10),
 661 | 									flooredExp10 < 0, 10, 0, exp10PartWidth - 1,
 662 | 								FLAGS_ZEROPAD | FLAGS_PLUS);
 663 | 		if (flags & FLAGS_LEFT) {
 664 | 			// We need to right-pad with spaces to meet the width requirement
 665 | 			while (output->pos - printentExpStartPos < width) {
 666 | 				putcharViaGadget(output, ' ');
 667 | 			}
 668 | 		}
 669 | 	}
 670 | }
 671 | #endif  // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 672 | 
 673 | static void printFloat(outputGadget_t* output, double value, printfSize_t precision, printfSize_t width, printfFlags_t flags, bool preferExponential) {
 674 | 	char buf[PRINTF_DECIMAL_BUFFER_SIZE];
 675 | 	printfSize_t len = 0U;
 676 | 
 677 | 	// test for special values
 678 | 	if (value != value) {
 679 | 		outRev_(output, "nan", 3, width, flags);
 680 | 		return;
 681 | 	}
 682 | 	if (value < -DBL_MAX) {
 683 | 		outRev_(output, "fni-", 4, width, flags);
 684 | 		return;
 685 | 	}
 686 | 	if (value > DBL_MAX) {
 687 | 		outRev_(output, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
 688 | 		return;
 689 | 	}
 690 | 
 691 | 	if (!preferExponential &&
 692 | 			((value > PRINTF_FLOAT_NOTATION_THRESHOLD) || (value < -PRINTF_FLOAT_NOTATION_THRESHOLD))) {
 693 | 		// The required behavior of standard printf is to print _every_ integral-part digit -- which could mean
 694 | 		// printing hundreds of characters, overflowing any fixed internal buffer and necessitating a more complicated
 695 | 		// implementation.
 696 | #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 697 | 		printExpontNum(output, value, precision, width, flags, buf, len);
 698 | #endif
 699 | 		return;
 700 | 	}
 701 | 
 702 | 	// set default precision, if not set explicitly
 703 | 	if (!(flags & FLAGS_PRECISION)) {
 704 | 		precision = PRINTF_DEFAULT_FLOAT_PRECISION;
 705 | 	}
 706 | 
 707 | 	// limit precision so that our integer holding the fractional part does not overflow
 708 | 	while ((len < PRINTF_DECIMAL_BUFFER_SIZE) && (precision > PRINTF_MAX_SUPPORTED_PRECISION)) {
 709 | 		buf[len++] = '0'; // This respects the precision in terms of result length only
 710 | 		precision--;
 711 | 	}
 712 | 
 713 | #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 714 | 	if (preferExponential)
 715 | 		printExpontNum(output, value, precision, width, flags, buf, len);
 716 | 	else
 717 | #endif
 718 | 		printDecimal(output, value, precision, width, flags, buf, len);
 719 | }
 720 | 
 721 | #endif  // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS)
 722 | 
 723 | // Advances the format pointer past the flags, and returns the parsed flags
 724 | // due to the characters passed
 725 | static printfFlags_t parseFlags(const char** format) {
 726 | 	printfFlags_t flags = 0U;
 727 | 	do {
 728 | 		switch (**format) {
 729 | 			case '0': flags |= FLAGS_ZEROPAD; (*format)++; break;
 730 | 			case '-': flags |= FLAGS_LEFT;    (*format)++; break;
 731 | 			case '+': flags |= FLAGS_PLUS;    (*format)++; break;
 732 | 			case ' ': flags |= FLAGS_SPACE;   (*format)++; break;
 733 | 			case '#': flags |= FLAGS_HASH;    (*format)++; break;
 734 | 			default : return flags;
 735 | 		}
 736 | 	} while (true);
 737 | }
 738 | 
 739 | static inline void formatStringLoop(outputGadget_t* output, const char* format, va_list args) {
 740 | #if PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER
 741 | #define ADVANCE_IN_FORMAT_STRING(cptr_) do { (cptr_)++; if (!*(cptr_)) return; } while(0)
 742 | #else
 743 | #define ADVANCE_IN_FORMAT_STRING(cptr_) (cptr_)++
 744 | #endif
 745 | 
 746 | 
 747 | 	while (*format) {
 748 | 		if (*format != '%') {
 749 | 			// A regular content character
 750 | 			putcharViaGadget(output, *format);
 751 | 			format++;
 752 | 			continue;
 753 | 		}
 754 | 		// We're parsing a format specifier: %[flags][width][.precision][length]
 755 | 		ADVANCE_IN_FORMAT_STRING(format);
 756 | 
 757 | 		printfFlags_t flags = parseFlags(&format);
 758 | 
 759 | 		// evaluate width field
 760 | 		printfSize_t width = 0U;
 761 | 		if (isdigit(*format)) {
 762 | 			width = (printfSize_t) atou_(&format);
 763 | 		}
 764 | 		else if (*format == '*') {
 765 | 			const int w = va_arg(args, int);
 766 | 			if (w < 0) {
 767 | 				flags |= FLAGS_LEFT;    // reverse padding
 768 | 				width = (printfSize_t)-w;
 769 | 			}
 770 | 			else {
 771 | 				width = (printfSize_t)w;
 772 | 			}
 773 | 			ADVANCE_IN_FORMAT_STRING(format);
 774 | 		}
 775 | 
 776 | 		// evaluate precision field
 777 | 		printfSize_t precision = 0U;
 778 | 		if (*format == '.') {
 779 | 			flags |= FLAGS_PRECISION;
 780 | 			ADVANCE_IN_FORMAT_STRING(format);
 781 | 			if (isdigit(*format)) {
 782 | 				precision = (printfSize_t) atou_(&format);
 783 | 			}
 784 | 			else if (*format == '*') {
 785 | 				const int precision_ = va_arg(args, int);
 786 | 				precision = precision_ > 0 ? (printfSize_t) precision_ : 0U;
 787 | 				ADVANCE_IN_FORMAT_STRING(format);
 788 | 			}
 789 | 		}
 790 | 
 791 | 		// evaluate length field
 792 | 		switch (*format) {
 793 | #ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
 794 | 			case 'I' : {
 795 | 				ADVANCE_IN_FORMAT_STRING(format);
 796 | 				// Greedily parse for size in bits: 8, 16, 32 or 64
 797 | 				switch(*format) {
 798 | 					case '8':               flags |= FLAGS_INT8;
 799 | 						ADVANCE_IN_FORMAT_STRING(format);
 800 | 						break;
 801 | 					case '1':
 802 | 						ADVANCE_IN_FORMAT_STRING(format);
 803 | 					if (*format == '6') { format++; flags |= FLAGS_INT16; }
 804 | 						break;
 805 | 					case '3':
 806 | 						ADVANCE_IN_FORMAT_STRING(format);
 807 | 						if (*format == '2') { ADVANCE_IN_FORMAT_STRING(format); flags |= FLAGS_INT32; }
 808 | 						break;
 809 | 					case '6':
 810 | 						ADVANCE_IN_FORMAT_STRING(format);
 811 | 						if (*format == '4') { ADVANCE_IN_FORMAT_STRING(format); flags |= FLAGS_INT64; }
 812 | 						break;
 813 | 					default: break;
 814 | 				}
 815 | 				break;
 816 | 			}
 817 | #endif
 818 | 			case 'l' :
 819 | 				flags |= FLAGS_LONG;
 820 | 				ADVANCE_IN_FORMAT_STRING(format);
 821 | 				if (*format == 'l') {
 822 | 					flags |= FLAGS_LONG_LONG;
 823 | 					ADVANCE_IN_FORMAT_STRING(format);
 824 | 				}
 825 | 				break;
 826 | 			case 'h' :
 827 | 				flags |= FLAGS_SHORT;
 828 | 				ADVANCE_IN_FORMAT_STRING(format);
 829 | 				if (*format == 'h') {
 830 | 					flags |= FLAGS_CHAR;
 831 | 					ADVANCE_IN_FORMAT_STRING(format);
 832 | 				}
 833 | 				break;
 834 | 			case 't' :
 835 | 				flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
 836 | 				ADVANCE_IN_FORMAT_STRING(format);
 837 | 				break;
 838 | 			case 'j' :
 839 | 				flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
 840 | 				ADVANCE_IN_FORMAT_STRING(format);
 841 | 				break;
 842 | 			case 'z' :
 843 | 				flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
 844 | 				ADVANCE_IN_FORMAT_STRING(format);
 845 | 				break;
 846 | 			default:
 847 | 				break;
 848 | 		}
 849 | 
 850 | 		// evaluate specifier
 851 | 		switch (*format) {
 852 | 			case 'd' :
 853 | 			case 'i' :
 854 | 			case 'u' :
 855 | 			case 'x' :
 856 | 			case 'X' :
 857 | 			case 'o' :
 858 | 			case 'b' : {
 859 | 
 860 | 				if (*format == 'd' || *format == 'i') {
 861 | 					flags |= FLAGS_SIGNED;
 862 | 				}
 863 | 
 864 | 				numericBase_t base;
 865 | 				if (*format == 'x' || *format == 'X') {
 866 | 					base = BASE_HEX;
 867 | 				}
 868 | 				else if (*format == 'o') {
 869 | 					base =  BASE_OCTAL;
 870 | 				}
 871 | 				else if (*format == 'b') {
 872 | 					base =  BASE_BINARY;
 873 | 				}
 874 | 				else {
 875 | 					base = BASE_DECIMAL;
 876 | 					flags &= ~FLAGS_HASH; // decimal integers have no alternative presentation
 877 | 				}
 878 | 
 879 | 				if (*format == 'X') {
 880 | 					flags |= FLAGS_UPPERCASE;
 881 | 				}
 882 | 
 883 | 				format++;
 884 | 				// ignore '0' flag when precision is given
 885 | 				if (flags & FLAGS_PRECISION) {
 886 | 					flags &= ~FLAGS_ZEROPAD;
 887 | 				}
 888 | 
 889 | 				if (flags & FLAGS_SIGNED) {
 890 | 					// A signed specifier: d, i or possibly I + bit size if enabled
 891 | 
 892 | 					if (flags & FLAGS_LONG_LONG) {
 893 | #if PRINTF_SUPPORT_LONG_LONG
 894 | 						const long long value = va_arg(args, long long);
 895 | 						printInt(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags);
 896 | #endif
 897 | 					}
 898 | 					else if (flags & FLAGS_LONG) {
 899 | 						const long value = va_arg(args, long);
 900 | 						printInt(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags);
 901 | 					}
 902 | 					else {
 903 | 						// We never try to interpret the argument as something potentially-smaller than int,
 904 | 						// due to integer promotion rules: Even if the user passed a short int, short unsigned
 905 | 						// etc. - these will come in after promotion, as int's (or unsigned for the case of
 906 | 						// short unsigned when it has the same size as int)
 907 | 						const int value =
 908 | 							(flags & FLAGS_CHAR) ? (signed char) va_arg(args, int) :
 909 | 							(flags & FLAGS_SHORT) ? (short int) va_arg(args, int) :
 910 | 							va_arg(args, int);
 911 | 						printInt(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags);
 912 | 					}
 913 | 				}
 914 | 				else {
 915 | 					// An unsigned specifier: u, x, X, o, b
 916 | 
 917 | 					flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
 918 | 
 919 | 					if (flags & FLAGS_LONG_LONG) {
 920 | #if PRINTF_SUPPORT_LONG_LONG
 921 | 						printInt(output, (printfUnsignedValue_t) va_arg(args, unsigned long long), false, base, precision, width, flags);
 922 | #endif
 923 | 					}
 924 | 					else if (flags & FLAGS_LONG) {
 925 | 						printInt(output, (printfUnsignedValue_t) va_arg(args, unsigned long), false, base, precision, width, flags);
 926 | 					}
 927 | 					else {
 928 | 						const unsigned int value =
 929 | 							(flags & FLAGS_CHAR) ? (unsigned char)va_arg(args, unsigned int) :
 930 | 							(flags & FLAGS_SHORT) ? (unsigned short int)va_arg(args, unsigned int) :
 931 | 							va_arg(args, unsigned int);
 932 | 						printInt(output, (printfUnsignedValue_t) value, false, base, precision, width, flags);
 933 | 					}
 934 | 				}
 935 | 				break;
 936 | 			}
 937 | #if PRINTF_SUPPORT_DECIMAL_SPECIFIERS
 938 | 			case 'f' :
 939 | 			case 'F' :
 940 | 				if (*format == 'F') flags |= FLAGS_UPPERCASE;
 941 | 				printFloat(output, va_arg(args, double), precision, width, flags, PRINTF_PREFER_DECIMAL);
 942 | 				format++;
 943 | 				break;
 944 | #endif
 945 | #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 946 | 			case 'e':
 947 | 			case 'E':
 948 | 			case 'g':
 949 | 			case 'G':
 950 | 				if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
 951 | 				if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
 952 | 				printFloat(output, va_arg(args, double), precision, width, flags, PRINTF_PREFER_EXPONENTIAL);
 953 | 				format++;
 954 | 				break;
 955 | #endif  // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 956 | 			case 'c' : {
 957 | 				printfSize_t l = 1U;
 958 | 				// pre padding
 959 | 				if (!(flags & FLAGS_LEFT)) {
 960 | 					while (l++ < width) {
 961 | 						putcharViaGadget(output, ' ');
 962 | 					}
 963 | 				}
 964 | 				// char output
 965 | 				putcharViaGadget(output, (char) va_arg(args, int) );
 966 | 				// post padding
 967 | 				if (flags & FLAGS_LEFT) {
 968 | 					while (l++ < width) {
 969 | 						putcharViaGadget(output, ' ');
 970 | 					}
 971 | 				}
 972 | 				format++;
 973 | 				break;
 974 | 			}
 975 | 
 976 | 			case 's' : {
 977 | 				const char* p = va_arg(args, char*);
 978 | 				if (p == NULL) {
 979 | 					outRev_(output, ")llun(", 6, width, flags);
 980 | 				}
 981 | 				else {
 982 | 					printfSize_t l = (printfSize_t)strnlen_s(p, precision ? precision : PRINTF_MAX_POSSIBLE_BUFFER_SIZE);
 983 | 					// pre padding
 984 | 					if (flags & FLAGS_PRECISION) {
 985 | 						l = (l < precision ? l : precision);
 986 | 					}
 987 | 					if (!(flags & FLAGS_LEFT)) {
 988 | 						while (l++ < width) {
 989 | 							putcharViaGadget(output, ' ');
 990 | 						}
 991 | 					}
 992 | 					// string output
 993 | 					while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision)) {
 994 | 						putcharViaGadget(output, *(p++));
 995 | 						--precision;
 996 | 					}
 997 | 					// post padding
 998 | 					if (flags & FLAGS_LEFT) {
 999 | 						while (l++ < width) {
1000 | 							putcharViaGadget(output, ' ');
1001 | 						}
1002 | 					}
1003 | 				}
1004 | 				format++;
1005 | 				break;
1006 | 			}
1007 | 
1008 | 			case 'p' : {
1009 | 				width = sizeof(void*) * 2U + 2; // 2 hex chars per byte + the "0x" prefix
1010 | 				flags |= FLAGS_ZEROPAD | FLAGS_POINTER;
1011 | 				uintptr_t value = (uintptr_t)va_arg(args, void*);
1012 | 				printInt(output, (printfUnsignedValue_t) value, false, BASE_HEX, precision, width, flags);
1013 | 				format++;
1014 | 				break;
1015 | 			}
1016 | 
1017 | 			case '%' :
1018 | 				putcharViaGadget(output, '%');
1019 | 				format++;
1020 | 				break;
1021 | 
1022 | 			// Many people prefer to disable support for %n, as it lets the caller
1023 | 			// engineer a write to an arbitrary location, of a value the caller
1024 | 			// effectively controls - which could be a security concern in some cases.
1025 | #if PRINTF_SUPPORT_WRITEBACK_SPECIFIER
1026 | 			case 'n' : {
1027 | 				if       (flags & FLAGS_CHAR)      *(va_arg(args, char*))      = (char) output->pos;
1028 | 				else if  (flags & FLAGS_SHORT)     *(va_arg(args, short*))     = (short) output->pos;
1029 | 				else if  (flags & FLAGS_LONG)      *(va_arg(args, long*))      = (long) output->pos;
1030 | #if PRINTF_SUPPORT_LONG_LONG
1031 | 				else if  (flags & FLAGS_LONG_LONG) *(va_arg(args, long long*)) = (long long int) output->pos;
1032 | #endif // PRINTF_SUPPORT_LONG_LONG
1033 | 				else                               *(va_arg(args, int*))       = (int) output->pos;
1034 | 				format++;
1035 | 				break;
1036 | 			}
1037 | #endif // PRINTF_SUPPORT_WRITEBACK_SPECIFIER
1038 | 
1039 | 			default :
1040 | 				putcharViaGadget(output, *format);
1041 | 				format++;
1042 | 				break;
1043 | 		}
1044 | 	}
1045 | }
1046 | 
1047 | // internal vsnprintf - used for implementing _all library functions
1048 | static int vsnprintf_impl(outputGadget_t* output, const char* format, va_list args) {
1049 | 	// Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is
1050 | 	// possible to call this function with a non-zero pos value for some "remedial printing".
1051 | 	formatStringLoop(output, format, args);
1052 | 
1053 | 	// termination
1054 | 	appendTermWithGadget(output);
1055 | 
1056 | 	// return written chars without terminating \0
1057 | 	return (int)output->pos;
1058 | }
1059 | 
1060 | ///////////////////////////////////////////////////////////////////////////////
1061 | 
1062 | int vprintf(const char* format, va_list arg) {
1063 | 	outputGadget_t gadget = externPutcharGadget();
1064 | 	return vsnprintf_impl(&gadget, format, arg);
1065 | }
1066 | 
1067 | int vsnprintf(char* s, size_t n, const char* format, va_list arg) {
1068 | 	outputGadget_t gadget = bufferGadget(s, n);
1069 | 	return vsnprintf_impl(&gadget, format, arg);
1070 | }
1071 | 
1072 | int vsprintf(char* s, const char* format, va_list arg) {
1073 | 	return vsnprintf(s, PRINTF_MAX_POSSIBLE_BUFFER_SIZE, format, arg);
1074 | }
1075 | 
1076 | int vfctprintf(void (*out)(char c, void* extraArg), void* extraArg, const char* format, va_list arg) {
1077 | 	outputGadget_t gadget = functionGadget(out, extraArg);
1078 | 	return vsnprintf_impl(&gadget, format, arg);
1079 | }
1080 | 
1081 | int printf(const char* format, ...) {
1082 | 	va_list args;
1083 | 	va_start(args, format);
1084 | 	const int ret = vprintf(format, args);
1085 | 	va_end(args);
1086 | 	return ret;
1087 | }
1088 | 
1089 | int sprintf(char* s, const char* format, ...) {
1090 | 	va_list args;
1091 | 	va_start(args, format);
1092 | 	const int ret = vsprintf(s, format, args);
1093 | 	va_end(args);
1094 | 	return ret;
1095 | }
1096 | 
1097 | int snprintf(char* s, size_t n, const char* format, ...) {
1098 | 	va_list args;
1099 | 	va_start(args, format);
1100 | 	const int ret = vsnprintf(s, n, format, args);
1101 | 	va_end(args);
1102 | 	return ret;
1103 | }
1104 | 
1105 | int fctprintf(void (*out)(char c, void* extraArg), void* extraArg, const char* format, ...) {
1106 | 	va_list args;
1107 | 	va_start(args, format);
1108 | 	const int ret = vfctprintf(out, extraArg, format, args);
1109 | 	va_end(args);
1110 | 	return ret;
1111 | }


--------------------------------------------------------------------------------