+CC="/home/anton/prj/osdev/sysroot/bin/i686-sb-gcc"

+CFLAGS = -ggdb -O2 -Wall -Wextra -pedantic -static

+LIB=-L../libgui -lgui -lgcc

+INC=-I../libgui/

+BINS=ante

+all: $(BINS)

+

+ante.o: ante.c

+ $(CC) $(CFLAGS) $(INC) $(LIB) -o $@ -c $<

+

+ante: ante.o

+ $(CC) $(CFLAGS) -o $@ $^ $(LIB)

+

+clean:

+ rm $(BINS) *.o

+#include <assert.h>

+#include <fcntl.h>

+#include <libgui.h>

+#include <poll.h>

+#include <pty.h>

+#include <socket.h>

+#include <stddef.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <unistd.h>

+

+#define BACKGROUND_COLOR 0x000000

+

+int file_fd;

+char *file_buffer;

+uint64_t file_buffer_size;

+uint64_t file_size = 0;

+uint64_t file_real_position = 0;

+GUI_Window *global_w;

+

+typedef enum {

+ NORMAL,

+ INSERT,

+ COMMAND,

+} editor_mode_t;

+

+editor_mode_t current_mode = NORMAL;

+uint32_t cursor_pos_x = 0;

+uint64_t cursor_pos_y = 0;

+void draw_file(void);

+void write_file(void);

+

+int clamp(int *x, int *y) {

+ int clamped = 0;

+ if (*x < 0) {

+ *x = 0;

+ clamped = 1;

+ }

+ if (*y < 0) {

+ *y = 0;

+ clamped = 1;

+ }

+ if (*x + 8 > global_w->sx) {

+ *x = (global_w->sx - 8) / 8;

+ clamped = 1;

+ }

+ if (*y + 8 > global_w->sy) {

+ *y = (global_w->sy - 8) / 8;

+ clamped = 1;

+ }

+ return clamped;

+}

+

+void insert_char(int pos, char c) {

+ if (0 == file_size) {

+ file_size++;

+ file_buffer[0] = c;

+ return;

+ }

+

+ // Shift the buffer at 'pos' to the right by one.

+ memmove(file_buffer + pos + 1, file_buffer + pos, file_size - pos);

+

+ file_buffer[pos] = c;

+ file_size++;

+}

+

+void delete_char(int pos, int *deleted_newline) {

+ if (0 == pos) {

+ return;

+ }

+ // Delete the characther at 'pos'. This makes sense if 'pos' is

+ // at the end of the file and as a result the shift operation done

+ // later in the function is not overwritting the characther.

+ if ('\n' == file_buffer[pos - 1])

+ *deleted_newline = 1;

+ file_buffer[pos - 1] = 0;

+

+ // Shift the buffer at 'pos' to the left by one

+ memmove(file_buffer + pos - 1, file_buffer + pos, file_size - pos);

+ file_size--;

+}

+

+uint64_t cursor_to_real(int x, int y, int *is_valid) {

+ *is_valid = 0;

+ if (clamp(&x, &y))

+ return file_real_position;

+ if (0 == file_size) {

+ if (0 == x && 0 == y) {

+ *is_valid = 1;

+ return 0;

+ }

+ return 0;

+ }

+ uint64_t p = 0;

+ int cx = 0;

+ int cy = 0;

+ for (; p < file_size; p++) {

+ if (cx == x && cy == y) {

+ *is_valid = 1;

+ break;

+ }

+ if ('\n' == file_buffer[p]) {

+ cx = 0;

+ cy++;

+ continue;

+ }

+ cx++;

+ }

+ if (*is_valid)

+ return p;

+ else

+ return file_real_position;

+}

+

+void key_event(char c) {

+ int x = 0;

+ int y = 0;

+ if (COMMAND == current_mode) {

+ if ('w' == c) {

+ printf("wrote to file\n");

+ write_file();

+ current_mode = NORMAL;

+ return;

+ }

+ if ('q' == c) {

+ close(file_fd);

+ close(global_w->ws_socket);

+ current_mode = NORMAL;

+ exit(0);

+ return;

+ }

+ return;

+ } else if (NORMAL == current_mode) {

+ switch (c) {

+ case 'j':

+ y++;

+ break;

+ case 'k':

+ y--;

+ break;

+ case 'l':

+ x++;

+ break;

+ case 'h':

+ x--;

+ break;

+ case 'c':

+ printf("entering command mode\n");

+ current_mode = COMMAND;

+ return;

+ break;

+ case 'i':

+ current_mode = INSERT;

+ return;

+ break;

+ default:

+ return;

+ }

+ } else {

+ if ('\x1B' == c) {

+ current_mode = NORMAL;

+ return;

+ }

+ if ('\b' == c) {

+ int deleted_newline = 0;

+ delete_char(file_real_position, &deleted_newline);

+ if (deleted_newline) {

+ y--;

+ } else {

+ x--;

+ }

+ GUI_ClearScreen(global_w, BACKGROUND_COLOR);

+ } else {

+ insert_char(file_real_position, c);

+ printf("inserting char: %c\n", c);

+ if ('\n' == c) {

+ cursor_pos_x = 0;

+ y++;

+ } else {

+ x++;

+ }

+ GUI_ClearScreen(global_w, BACKGROUND_COLOR);

+ }

+ }

+

+ int is_valid_position = 0;

+ file_real_position =

+ cursor_to_real(cursor_pos_x + x, cursor_pos_y + y, &is_valid_position);

+ if (!is_valid_position) {

+ return;

+ }

+ GUI_OverwriteFont(global_w, cursor_pos_x * 8, cursor_pos_y * 8,

+ BACKGROUND_COLOR);

+ draw_file();

+ cursor_pos_x += x;

+ cursor_pos_y += y;

+ GUI_OverwriteFont(global_w, cursor_pos_x * 8, cursor_pos_y * 8, 0xFFFFFF);

+

+ GUI_UpdateWindow(global_w);

+}

+

+void draw_file(void) {

+ assert(file_buffer);

+ uint32_t screen_pos_x = 0;

+ uint64_t screen_pos_y = 0;

+ for (uint64_t i = 0; i < file_size; i++) {

+ char c = file_buffer[i];

+ if ('\n' == c) {

+ screen_pos_x = 0;

+ screen_pos_y += 8;

+ continue;

+ }

+ GUI_DrawFont(global_w, screen_pos_x, screen_pos_y, c);

+ screen_pos_x += 8;

+ }

+}

+

+void write_file(void) {

+ assert(file_buffer);

+ pwrite(file_fd, file_buffer, file_size, 0);

+}

+

+int open_file(const char *file) {

+ file_fd = open(file, O_RDWR, O_CREAT);

+ printf("file_fd: %d\n", file_fd);

+ if (0 > file_fd) {

+ perror("open");

+ return 0;

+ }

+

+ file_buffer_size = 0x1000;

+ file_buffer = malloc(file_buffer_size);

+ uint64_t index = 0;

+ assert(file_buffer);

+ for (;;) {

+ char buffer[4096];

+ int rc = read(file_fd, buffer, 4096);

+ if (-1 == rc) {

+ perror("read");

+ assert(0);

+ }

+

+ if (0 == rc)

+ break;

+

+ file_size += rc;

+ if (file_size > file_buffer_size) {

+ file_buffer_size = file_size;

+ file_buffer = realloc(file_buffer, file_buffer_size);

+ assert(file_buffer);

+ }

+

+ for (int i = 0; i < rc; i++, index++) {

+ file_buffer[index] = buffer[i];

+ }

+ }

+ return 1;

+}

+

+void run() {

+ struct pollfd fds[1];

+ fds[0].fd = global_w->ws_socket;

+ fds[0].events = POLLIN;

+ fds[0].revents = 0;

+ for (;; fds[0].revents = 0) {

+ poll(fds, 1, 0);

+ if (fds[0].revents & POLLIN) {

+ WS_EVENT e;

+ int rc;

+ if (0 >= (rc = read(global_w->ws_socket, &e, sizeof(e))))

+ continue;

+ if (0 == e.c)

+ continue;

+ key_event(e.c);

+ }

+ }

+}

+

+int main(int argc, char **argv) {

+ if (argc < 2) {

+ printf("File has to be specified.\n");

+ return 1;

+ }

+ global_w = GUI_CreateWindow(10, 10, 150 * 4, 150 * 4);

+ assert(global_w);

+ GUI_ClearScreen(global_w, BACKGROUND_COLOR);

+ GUI_UpdateWindow(global_w);

+

+ assert(open_file(argv[1]));

+ draw_file();

+ run();

+ return 0;

+}

+CC="/home/anton/opt/cross/bin/i686-elf-gcc"

+CFLAGS = -ggdb -ffreestanding -O0 -Wall -Wextra -pedantic -mgeneral-regs-only -Wimplicit-fallthrough

+BINS=cat

+all: $(BINS)

+

+cat.o: cat.c

+ $(CC) $(CFLAGS) -L../libc/ -lc -c cat.c -I../libc/

+

+cat: cat.o

+ $(CC) -shared -o cat -ffreestanding -nostdlib $(CFLAGS) cat.o -L../libc/ -lc -lgcc #-L../libc/c.a

+#include <fcntl.h>

+#include <stdio.h>

+#include <dirent.h>

+

+int main(int argc, char **argv) {

+ DIR *d = opendir("/");

+ struct dirent *de = readdir(d);

+ printf("x : %x\n", de->d_name[0]);

+ for (;;)

+ ;

+ /*

+ int fd = 0;

+ if (argc < 2)

+ goto read_stdin;

+ for (int i = 1; i < argc; i++) {

+ if ((fd = open(argv[i], O_RDONLY, 0)) == -1) {

+ return 1;

+ }

+ read_stdin:

+ for (char c[4096], int rc; (rc = read(fd, c, 4096) > 0);)

+ write(1, c, rc);

+ }*/

+ return 0;

+}

+CC="/home/anton/opt/cross/bin/i686-elf-gcc"

+CFLAGS = -ggdb -ffreestanding -O0 -Wall -Wextra -pedantic -mgeneral-regs-only -Wimplicit-fallthrough

+BINS=init

+all: $(BINS)

+

+init.o: init.c

+ $(CC) $(CFLAGS) -I../libc/ -L../libc/ -lc -c init.c

+

+init: init.o

+ $(CC) -shared -o init -ffreestanding -nostdlib $(CFLAGS) init.o -L../libc/ -lc -lgcc #-L../libc/c.a

+#include <stdint.h>

+int main(int argc, char **argv);

+//int main();

+

+void _start(int a, int b, int argc, char** argv)

+{

+ (void)a;

+ kprintf("argc : %x\n", &argc);

+ kprintf("argv : %x\n", &argv);

+ for(;;);

+// main(argc, t);

+}

+#include <stdarg.h>

+#include <stddef.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <unistd.h>

+

+int main(void) {

+ if (fork())

+ for (;;)

+ wait(NULL);

+

+ char *a[] = {NULL};

+ execv("/term", a);

+ return 1;

+}

+#CC="/home/anton/opt/cross/bin/i686-elf-gcc"

+#AR="/home/anton/opt/cross/bin/i686-elf-ar"

+CC="/home/anton/prj/osdev/sysroot/bin/i686-sb-gcc"

+AR="/home/anton/prj/osdev/sysroot/bin/i686-sb-ar"

+CFLAGS = -O0 -Wall -Wextra -pedantic -Wimplicit-fallthrough -static -Wno-undef

+BINS=libjson.a

+all: $(BINS)

+LIBS=-L./hashmap -lhashmap

+OBJ=json.o

+

+json.o: json.c

+ $(CC) $(CFLAGS) $(LIBS) -c json.c

+

+libjson.a: $(OBJ)

+ $(AR) rcs libjson.a $^

+

+clean:

+ rm libjson.a json.o

+Subproject 07dfe3b606e0d82b2e181b27344b5e4ce8849f3

+//

+// Copyright (C) 2022 by Anton Kling <anton@kling.gg>

+//

+// SPDX-License-Identifier: BSD-2-Clause

+//

+#include "hashmap/hashmap.h"

+#include <assert.h>

+#include <math.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+typedef enum JSON_TYPE {

+ NONE,

+ STRING,

+ NUMBER,

+ OBJECT,

+ ARRAY, // FIXME

+ BOOL,

+ JSON_NULL,

+} JSON_TYPE;

+

+typedef struct JSON_ENTRY {

+ char *name;

+ JSON_TYPE type;

+ void *value;

+} JSON_ENTRY;

+

+typedef struct JSON_OBJECT {

+ size_t size;

+ JSON_ENTRY *entries;

+ HashMap *hash_indexes;

+} JSON_OBJECT;

+

+typedef struct JSON_CTX {

+ JSON_ENTRY global_object;

+} JSON_CTX;

+

+void JSON_Init(JSON_CTX *ctx) {

+ ctx->global_object.name = NULL;

+ ctx->global_object.type = OBJECT;

+ ctx->global_object.value = malloc(sizeof(JSON_OBJECT));

+ JSON_OBJECT *obj = ctx->global_object.value;

+ obj->size = 0;

+ obj->entries = NULL;

+}

+

+const char *skip_whitespace(const char *str) {

+ for (; *str; str++)

+ switch (*str) {

+ case ' ':

+ case '\t':

+ case '\n':

+ case '\r':

+ break;

+ default:

+ goto _exit;

+ }

+_exit:

+ return str;

+}

+

+char to_lower(char c) {

+ if (c <= 'Z')

+ return c | 32;

+ return c;

+}

+

+int low_strequ(const char *s1, const char *s2, size_t l) {

+ for (; 0 < l; l--, s2++, s1++) {

+ if (to_lower(*s2) != to_lower(*s1))

+ return 0;

+ }

+ return 1;

+}

+

+const char *find_name(const char *json, char *name_buffer, size_t buffer_len,

+ size_t *name_length, int *rc) {

+ *rc = 0;

+ json = skip_whitespace(json);

+ if ('"' != *json)

+ return json;

+

+ // This *can* be the name

+ json++;

+ const char *tmp = json;

+ for (; *tmp && '"' != *tmp; tmp++)

+ ;

+ if (!(*tmp && ':' == *(tmp + 1))) {

+ // Invalid name

+ // FIXME: Do something better than this.

+ assert(0);

+ }

+ // The name was found.

+ *rc = 1;

+ size_t str_len;

+ if (tmp == json)

+ str_len = 0;

+ else

+ str_len = (tmp - json - 1);

+ if (str_len + 1 > buffer_len) {

+ // JSON string is too long for the buffer

+ // FIXME: Do something better than this.

+ assert(0);

+ }

+ memcpy(name_buffer, json, str_len + 1);

+ name_buffer[str_len + 1] = '\0';

+ *name_length = str_len;

+ return tmp + 2;

+}

+

+const char *find_entry(const char *json, char *name_buffer, size_t buffer_len,

+ size_t *name_length, JSON_TYPE *entry_type, int *rc) {

+ *rc = 0;

+ json = skip_whitespace(json);

+ json = find_name(json, name_buffer, 4096, name_length, rc);

+ json = skip_whitespace(json);

+ switch (*json) {

+ case '{':

+ *entry_type = OBJECT;

+ break;

+ case '"':

+ *entry_type = STRING;

+ break;

+ case '0':

+ case '1':

+ case '2':

+ case '3':

+ case '4':

+ case '5':

+ case '6':

+ case '7':

+ case '8':

+ case '9':

+ *entry_type = NUMBER;

+ break;

+ case '[':

+ *entry_type = ARRAY;

+ break;

+ case 'T':

+ case 'F':

+ case 't':

+ case 'f':

+ *entry_type = BOOL;

+ break;

+ case 'N':

+ case 'n':

+ *entry_type = JSON_NULL;

+ break;

+ case '}':

+ *rc = 2;

+ break;

+ default:

+ *entry_type = NONE;

+ break;

+ }

+ return json;

+}

+

+const char *extract_int(const char *json, uint32_t **value, int *rc) {

+ *value = malloc(sizeof(uint32_t));

+ *rc = 0;

+ json = skip_whitespace(json);

+ // FIXME: Do some checking to determine that this is a int.

+ **value = 0;

+ for (; *json && ',' != *json && '}' != *json;) {

+ **value *= 10;

+ **value += (uint32_t)(*json - '0');

+ json++;

+ json = skip_whitespace(json);

+ }

+ if ('\0' != *json)

+ *rc = 1;

+ return json;

+}

+

+const char *extract_string(const char *json, char **value, int *rc) {

+ *value = malloc(4096);

+ *rc = 0;

+ int escape = 0;

+ json++;

+ char *tmp = *value;

+ for (; *json; json++) {

+ if ('"' == *json && !escape)

+ break;

+ escape = 0;

+

+ if ('\\' == *json && !escape) {

+ escape = 1;

+ continue;

+ }

+ *tmp = *json;

+ tmp++;

+ }

+ *tmp = '\0';

+ if ('\0' != *json)

+ *rc = 1;

+ return json;

+}

+

+const char *extract_bool(const char *json, uint8_t **value, int *rc) {

+ *value = malloc(sizeof(uint8_t));

+ *rc = 0;

+ if (low_strequ(json, "true", 3)) {

+ **value = 1;

+ json += 4;

+ *rc = 1;

+ return json;

+ } else if (low_strequ(json, "false", 4)) {

+ **value = 0;

+ json += 5;

+ *rc = 1;

+ return json;

+ }

+ return json;

+}

+

+const char *extract_null(const char *json, uint8_t **value, int *rc) {

+ *value = malloc(sizeof(uint8_t));

+ *rc = 0;

+

+ if (low_strequ(json, "null", 3)) {

+ **value = 0;

+ json += 4;

+ *rc = 1;

+ return json;

+ }

+ return json;

+}

+

+void hashmap_free_value(char *key, void *value) {

+ (void)key;

+ free(value);

+}

+

+JSON_ENTRY *JSON_at(JSON_ENTRY *entry, size_t i);

+

+void JSON_Parse(JSON_CTX *ctx, const char *json) {

+ int rc;

+ char name_buffer[4096];

+ size_t name_length;

+ JSON_TYPE entry_type;

+ JSON_OBJECT *object_stack[64];

+ memset(object_stack, 0, sizeof(JSON_OBJECT *[64]));

+ size_t parent_num = 0;

+ object_stack[parent_num] = ctx->global_object.value;

+ object_stack[parent_num]->size = 0;

+

+ for (;; json++) {

+ json = find_entry(json, name_buffer, 4096, &name_length, &entry_type, &rc);

+ if ('\0' == *json)

+ return;

+

+ if (2 == rc) {

+ if (0 == parent_num)

+ return;

+ parent_num--;

+ json++;

+ json = skip_whitespace(json);

+ if (',' == *json)

+ json++;

+ continue;

+ }

+

+ if (NULL == object_stack[parent_num]->entries) {

+ object_stack[parent_num]->entries = malloc(sizeof(JSON_ENTRY[30]));

+ object_stack[parent_num]->size = 0;

+ object_stack[parent_num]->hash_indexes = hashmap_create(30);

+ }

+

+ size_t entry_num = object_stack[parent_num]->size;

+ object_stack[parent_num]->size++;

+

+ if (NULL == object_stack[parent_num]->entries) {

+ void *rc = object_stack[parent_num]->entries =

+ malloc(sizeof(JSON_ENTRY[30]));

+ object_stack[parent_num]->entries = rc;

+ object_stack[parent_num]->size = 0;

+ object_stack[parent_num]->hash_indexes = hashmap_create(30);

+ }

+ JSON_ENTRY *entry = &object_stack[parent_num]->entries[entry_num];

+ if (1 == rc) {

+ name_length++;

+ entry->name = malloc(name_length + 2);

+ memcpy(entry->name, name_buffer, name_length);

+ entry->name[name_length] = '\0';

+ size_t *b = malloc(sizeof(size_t));

+ *b = entry_num;

+ hashmap_add_entry(object_stack[parent_num]->hash_indexes, entry->name, b,

+ hashmap_free_value, 1);

+ } else {

+ entry->name = NULL;

+ }

+ entry->type = entry_type;

+ if (OBJECT == entry_type) {

+ entry->value = malloc(sizeof(JSON_OBJECT));

+ parent_num++;

+ object_stack[parent_num] = entry->value;

+ object_stack[parent_num]->entries = NULL;

+ continue;

+ } else if (NUMBER == entry_type) {

+ json = extract_int(json, (uint32_t **)&entry->value, &rc);

+ } else if (STRING == entry_type) {

+ json = extract_string(json, (char **)&entry->value, &rc);

+ } else if (BOOL == entry_type) {

+ json = extract_bool(json, (uint8_t **)&entry->value, &rc);

+ } else if (JSON_NULL == entry_type) {

+ json = extract_null(json, (uint8_t **)&entry->value, &rc);

+ }

+ json++;

+ }

+}

+

+JSON_ENTRY *JSON_at(JSON_ENTRY *entry, size_t i) {

+ if (OBJECT != entry->type)

+ return NULL;

+ return &((JSON_OBJECT *)(entry->value))->entries[i];

+}

+

+JSON_ENTRY *JSON_search_name(JSON_ENTRY *entry, char *name) {

+ if (OBJECT != entry->type)

+ return NULL;

+ size_t *i =

+ hashmap_get_entry(((JSON_OBJECT *)(entry->value))->hash_indexes, name);

+ if (!i)

+ return NULL;

+ return JSON_at(entry, *i);

+}

+

+void write_entry_content(int fd, size_t indent, JSON_ENTRY *entry) {

+#define PLACE_TABS \

+ { \

+ for (size_t i = 0; i < indent; i++) \

+ dprintf(fd, "\t"); \

+ }

+ PLACE_TABS

+ if (entry->name)

+ dprintf(fd, "\"%s\": ", entry->name);

+ if (OBJECT == entry->type) {

+ JSON_OBJECT *object = entry->value;

+ dprintf(fd, "{\n");

+ for (size_t i = 0; i < object->size; i++)

+ write_entry_content(fd, indent + 1, &object->entries[i]);

+ PLACE_TABS

+ dprintf(fd, "},\n");

+ } else if (NUMBER == entry->type)

+ dprintf(fd, "%d,\n", *(uint32_t *)entry->value);

+ else if (STRING == entry->type)

+ dprintf(fd, "\"%s\",\n", (char *)entry->value);

+ else if (BOOL == entry->type)

+ dprintf(fd, "%s,\n", ((*(uint8_t *)entry->value) ? "true" : "false"));

+ else if (JSON_NULL == entry->type)

+ dprintf(fd, "null,\n");

+}

+

+void JSON_extract_fd(JSON_CTX *ctx, int fd) {

+ JSON_ENTRY *entry = &ctx->global_object;

+ write_entry_content(fd, 0, &((JSON_OBJECT *)entry->value)->entries[0]);

+}

+#ifndef JSON_H

+#define JSON_H

+#include "hashmap/hashmap.h"

+#include <stddef.h>

+#include <stdint.h>

+

+typedef enum JSON_TYPE {

+ NONE,

+ STRING,

+ NUMBER,

+ OBJECT,

+ ARRAY, // FIXME

+ BOOL,

+ JSON_NULL,

+} JSON_TYPE;

+

+typedef struct JSON_ENTRY {

+ char *name;

+ JSON_TYPE type;

+ void *value;

+} JSON_ENTRY;

+

+typedef struct JSON_OBJECT {

+ uint64_t size;

+ JSON_ENTRY *entries;

+ HashMap *hash_indexes;

+} JSON_OBJECT;

+

+typedef struct JSON_CTX {

+ JSON_ENTRY global_object;

+} JSON_CTX;

+

+void JSON_Init(JSON_CTX *ctx);

+void JSON_Parse(JSON_CTX *ctx, const char *json);

+void JSON_extract_fd(JSON_CTX *ctx, int whitespace, int fd);

+uint64_t JSON_extract_length(JSON_CTX *ctx, int whitespace);

+JSON_ENTRY *JSON_at(JSON_ENTRY *entry, uint64_t i);

+JSON_ENTRY *JSON_search_name(JSON_ENTRY *entry, char *name);

+#endif

+CC="/home/anton/prj/osdev/sysroot/bin/i686-sb-gcc"

+AR="/home/anton/prj/osdev/sysroot/bin/i686-sb-ar"

+AS="/home/anton/prj/osdev/sysroot/bin/i686-sb-as"

+#CFLAGS = -ggdb -ffreestanding -O0 -Wall -Wextra -pedantic -mgeneral-regs-only -Wimplicit-fallthrough -I./include/ -static -fsanitize=shift,signed-integer-overflow,bounds

+CFLAGS = -ggdb -ffreestanding -O2 -Wall -pedantic -Wimplicit-fallthrough -I./include/ -static

+#BINS=c.a libc.o crt0.o malloc.o pty.o mmap.o

+OBJ=crt0.o libc.o malloc/malloc.o pty.o sys/mman/mmap.o memset.o assert.o stdio/snprintf.o stdio/vfprintf.o string/memcpy.o string/memcmp.o string/strcmp.o ubsan.o string/strcpy.o isspace.o stdio/puts.o stdio/putchar.o dirent/opendir.o dirent/readdir.o dirent/closedir.o unistd/getopt.o dirent/scandir.o dirent/alphasort.o stdio/printf.o stdio/vdprintf.o stdio/vprintf.o stdio/dprintf.o stdio/vprintf.o string/strlen.o string/strnlen.o stdio/stdin.o stdio/stdout.o stdio/stderr.o stdio/getchar.o stdio/fgetc.o arpa/inet/htons.o arpa/inet/htonl.o stdio/fread.o stdio/fwrite.o stdio/fopen.o stdio/fclose.o stdio/fseek.o ctype/isascii.o stdio/fprintf.o stdlib/atoi.o stdlib/strtol.o ctype/toupper.o ctype/tolower.o string/strcat.o string/strchr.o string/sscanf.o sys/stat/stat.o stdlib/getenv.o string/strrchr.o stdio/ftell.o stdio/tmpfile.o stdio/fgets.o stdio/feof.o stdio/fscanf.o stdio/ungetc.o string/strncmp.o stdio/fputc.o string/strncpy.o stdio/remove.o stdio/ferror.o stdio/fputs.o stdlib/rand.o stdlib/srand.o unistd/getpid.o stdlib/strtoul.o stdio/fflush.o stdlib/abort.o string/strcspn.o time/localtime.o time/time.o time/clock_gettime.o time/gmtime.o time/strftime.o string/strpbrk.o ctype/isdigit.o ctype/isalpha.o ctype/isxdigit.o ctype/ispunct.o stdio/setvbuf.o stdio/fileno.o stdio/putc.o stdio/sprintf.o stdlib/abs.o string/strspn.o stdlib/qsort.o string/memmove.o setjmp/longjmp.o setjmp/setjmp.o libgen/basename.o string/strdup.o string/strndup.o string/strlcpy.o stdlib/atexit.o stdio/open_memstream.o libgen/dirname.o unistd/unlink.o string/strstr.o string/strcasecmp.o string/strncasecmp.o stdlib/mkstemp.o string/strtok.o unistd/execvp.o unistd/_exit.o ctype/isalnum.o time/ctime_r.o stdlib/strtold.o sys/time/gettimeofday.o stdio/fgetpos.o stdio/fsetpos.o ctype/isprint.o stdlib/system.o stdio/tmpnam.o unistd/msleep.o stdlib/atof.o stdlib/strtod.o stdio/rename.o sys/stat/mkdir.o unistd/uptime.o

+#OBJ=crt0.o libc.o malloc/malloc.o pty.o sys/mman/mmap.o memset.o assert.o stdio/snprintf.o stdio/vfprintf.o string/memcpy.o string/memcmp.o string/strcmp.o ubsan.o string/strcpy.o isspace.o stdio/puts.o stdio/putchar.o dirent/opendir.o dirent/readdir.o dirent/closedir.o unistd/getopt.o dirent/scandir.o dirent/alphasort.o stdio/printf.o stdio/vdprintf.o stdio/vprintf.o stdio/dprintf.o stdio/vprintf.o string/strlen.o string/strnlen.o stdio/stdin.o stdio/stdout.o stdio/stderr.o stdio/getchar.o stdio/fgetc.o arpa/inet/htons.o arpa/inet/htonl.o stdio/fread.o stdio/fwrite.o stdio/fopen.o stdio/fclose.o stdio/fseek.o ctype/isascii.o stdio/fprintf.o stdlib/atoi.o stdlib/strtol.o ctype/toupper.o ctype/tolower.o string/strcat.o string/strchr.o string/sscanf.o sys/stat/stat.o stdlib/getenv.o string/strrchr.o stdio/ftell.o stdio/tmpfile.o stdio/fgets.o stdio/feof.o stdio/fscanf.o stdio/ungetc.o string/strncmp.o stdio/fputc.o string/strncpy.o stdio/remove.o stdio/ferror.o stdio/fputs.o stdlib/rand.o stdlib/srand.o unistd/getpid.o stdlib/strtoul.o stdio/fflush.o stdlib/abort.o string/strcspn.o time/localtime.o time/time.o time/clock_gettime.o time/gmtime.o time/strftime.o string/strpbrk.o ctype/isdigit.o ctype/isalpha.o ctype/isxdigit.o ctype/ispunct.o stdio/setvbuf.o stdio/fileno.o stdio/putc.o stdio/sprintf.o stdlib/abs.o string/strspn.o stdlib/qsort.o string/memmove.o setjmp/longjmp.o setjmp/setjmp.o

+all: libc.a

+

+%.o: %.c

+ $(CC) $(CFLAGS) -O0 -I. -o $@ -c $< -lgcc

+

+%.o: %.s

+ $(AS) $< -o $@

+

+libc.a: $(OBJ)

+ $(AR) rcs libc.a $(OBJ)

+

+install:

+ cp crt0.o /home/anton/prj/osdev/sysroot/lib/

+ cp libc.a /home/anton/prj/osdev/sysroot/lib/

+ cp -r include /home/anton/prj/osdev/sysroot/usr/

+

+clean:

+ rm libc.a *.o */*.o */*/*.o

+#include <stdint.h>

+

+uint32_t htonl(uint32_t hostlong);

+uint16_t htons(uint16_t hostlong);

+#include <arpa/inet.h>

+#include <endian.h>

+#include <stdint.h>

+

+uint32_t htonl(uint32_t hostlong) {

+#if BYTE_ORDER == LITTLE_ENDIAN

+ hostlong = (uint32_t)(htons(hostlong >> 16)) |

+ (uint32_t)(htons(hostlong & 0xFFFF) << 16);

+#endif

+ return hostlong;

+}

+#include <arpa/inet.h>

+#include <endian.h>

+#include <stdint.h>

+

+uint16_t htons(uint16_t hostlong) {

+#if BYTE_ORDER == LITTLE_ENDIAN

+ hostlong = ((hostlong & 0xFF00) >> 8) | ((hostlong & 0x00FF) << 8);

+#endif

+ return hostlong;

+}

+#include <assert.h>

+#include <stdio.h>

+#include <stdlib.h>

+

+void aFailed(char *f, int l) {

+ printf("Assert failed\n");

+ printf("%s : %d\n", f, l);

+ exit(1);

+}

+#ifndef ASSERT_H

+#define ASSERT_H

+

+#define assert(expr) \

+ { \

+ if (!(expr)) \

+ aFailed(__FILE__, __LINE__); \

+ }

+void aFailed(char *f, int l);

+#endif

+.global _start

+.extern main

+_start:

+ call main

+ mov %eax, %ebx

+ mov $8, %eax

+ int $0x80

+l:

+ nop

+ nop

+ nop

+ nop

+ jmp l

+#ifndef CTYPE_H

+#define CTYPE_H

+

+int isspace(int c);

+int isascii(int c);

+int toupper(int c);

+int tolower(int c);

+int isdigit(int c);

+int isalpha(int c);

+int isxdigit(int c);

+int ispunct(int c);

+#endif

+#include <ctype.h>

+

+// This is probably the most useless libc function I have seen so far.

+int isalnum(int c) {

+ return isalpha(c) || isdigit(c);

+}

+#include <ctype.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/isalpha.html

+int isalpha(int c) { return (('A' <= toupper(c)) && ('Z' >= toupper(c))); }

+#include <ctype.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/isascii.html

+int isascii(int c) { return (c < 128); }

+#include <ctype.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/isdigit.html

+int isdigit(int c) {

+ return ('0' <= c && c <= '9');

+}

+#include <ctype.h>

+

+int isprint(int c) { return c > 0x20 && 0x7F != c; }

+#include <ctype.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/ispunct.html

+int ispunct(int c) {

+ return (c == '.');

+}

+#include <ctype.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/isxdigit.html

+int isxdigit(int c) {

+ return isdigit(c) || ('A' >= toupper(c) && 'Z' <= toupper(c));

+}

+#include <ctype.h>

+

+int tolower(int c) {

+ if (c >= 'A' && c <= 'Z')

+ return c - 'A' + 'a';

+ return c;

+}

+#include <ctype.h>

+

+int toupper(int c) {

+ if (c >= 'a' && c <= 'z')

+ return c - 'a' + 'A';

+ return c;

+}

+#ifndef DIRENT_H

+#define DIRENT_H

+#include <fcntl.h>

+#include <limits.h>

+#include <stddef.h>

+#include <stdlib.h>

+#include <sys/types.h>

+#include <unistd.h>

+

+struct dirent {

+ ino_t d_ino; // File serial number.

+ char d_name[PATH_MAX]; // Filename string of entry.

+};

+

+typedef struct {

+ int fd;

+ struct dirent internal_direntry;

+ int dir_num;

+} DIR;

+

+DIR *opendir(const char *dirname);

+struct dirent *readdir(DIR *dir);

+int closedir(DIR *dirp);

+int alphasort(const struct dirent **d1, const struct dirent **d2);

+int scandir(const char *dir, struct dirent ***namelist,

+ int (*sel)(const struct dirent *),

+ int (*compar)(const struct dirent **, const struct dirent **));

+#endif

+#include <dirent.h>

+

+int alphasort(const struct dirent **d1, const struct dirent **d2) {

+ // TODO: Actually sort it

+ *d2 = *d1;

+ return 0;

+}

+#include <dirent.h>

+

+int closedir(DIR *dir) {

+ close(dir->fd);

+ free(dir);

+ return 0;

+}

+#include <dirent.h>

+

+DIR *opendir(const char *dirname) {

+ int fd = open(dirname, O_RDONLY, 0);

+ if (-1 == fd)

+ return NULL;

+ DIR *rc = malloc(sizeof(DIR));

+ rc->fd = fd;

+ rc->dir_num = 0;

+ return rc;

+}

+#include <dirent.h>

+

+struct dirent *readdir(DIR *dir) {

+ size_t offset = dir->dir_num * sizeof(struct dirent);

+ int rc;

+ if (-1 == (rc = pread(dir->fd, &dir->internal_direntry, sizeof(struct dirent),

+ offset)))

+ return NULL;

+ if (rc < sizeof(struct dirent))

+ return NULL;

+

+ dir->dir_num++;

+ return &(dir->internal_direntry);

+}

+#include <dirent.h>

+#include <stdlib.h>

+#include <string.h>

+

+int nop_sel(const struct dirent *unused) {

+ (void)unused;

+ return 1;

+}

+

+int nop_compar(const struct dirent **d1, const struct dirent **d2) {

+ *d2 = *d1;

+ return 0;

+}

+

+int scandir(const char *dir, struct dirent ***namelist,

+ int (*sel)(const struct dirent *),

+ int (*compar)(const struct dirent **, const struct dirent **)) {

+ if (!sel)

+ sel = nop_sel;

+

+ if (!compar)

+ compar = nop_compar;

+

+ DIR *d = opendir(dir);

+ struct dirent **list = NULL;

+ struct dirent *e;

+ int rc = 0;

+ for (; (e = readdir(d));) {

+ if (!sel(e))

+ continue;

+ struct dirent *p = malloc(sizeof(struct dirent));

+ memcpy(p, e, sizeof(struct dirent));

+ list = realloc(list, (rc + 1) * sizeof(struct dirent *));

+ list[rc] = p;

+ rc++;

+ }

+ // struct dirent **new_list;

+ // compar((const struct dirent **)list, (const struct dirent **)new_list);

+ // *namelist = new_list;

+ *namelist = list;

+ // closedir(d);

+ return rc;

+}

+#define LITTLE_ENDIAN 0

+#define BYTE_ORDER LITTLE_ENDIAN

+#ifndef ERRNO_H

+#define ERRNO_H

+// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html

+#define E2BIG 1 // Argument list too long.

+#define EACCES 2 // Permission denied.

+#define EADDRINUSE 3 // Address in use.

+#define EADDRNOTAVAIL 4 // Address not available.

+#define EAFNOSUPPORT 5 // Address family not supported.

+#define EAGAIN 6 // Resource unavailable, try again.

+#define EALREADY 7 // Connection already in progress.

+#define EBADF 8 // Bad file descriptor.

+#define EBADMSG 9 // Bad message.

+#define EBUSY 10 // Device or resource busy.

+#define ECANCELED 11 // Operation canceled.

+#define ECHILD 12 // No child processes.

+#define ECONNABORTED 13 // Connection aborted.

+#define ECONNREFUSED 14 // Connection refused.

+#define ECONNRESET 15 // Connection reset.

+#define EDEADLK 16 // Resource deadlock would occur.

+#define EDESTADDRREQ 17 // Destination address required.

+#define EDOM 18 // Mathematics argument out of domain of function.

+#define EDQUOT 19 // Reserved.

+#define EEXIST 20 // File exists.

+#define EFAULT 21 // Bad address.

+#define EFBIG 22 // File too large.

+#define EHOSTUNREACH 23 // Host is unreachable.

+#define EIDRM 24 // Identifier removed.

+#define EILSEQ 25 // Illegal byte sequence.

+#define EINPROGRESS 26 // Operation in progress.

+#define EINTR 27 // Interrupted function.

+#define EINVAL 28 // Invalid argument.

+#define EIO 29 // I/O error.

+#define EISCONN 30 // Socket is connected.

+#define EISDIR 31 // Is a directory.

+#define ELOOP 32 // Too many levels of symbolic links.

+#define EMFILE 33 // File descriptor value too large.

+#define EMLINK 34 // Too many links.

+#define EMSGSIZE 35 // Message too large.

+#define EMULTIHOP 36 // Reserved.

+#define ENAMETOOLONG 37 // Filename too long.

+#define ENETDOWN 38 // Network is down.

+#define ENETRESET 39 // Connection aborted by network.

+#define ENETUNREACH 40 // Network unreachable.

+#define ENFILE 41 // Too many files open in system.

+#define ENOBUFS 42 // No buffer space available.

+#define ENODATA 43 // No message is available on the STREAM head read queue.

+#define ENODEV 44 // No such device.

+#define ENOENT 45 // No such file or directory.

+#define ENOEXEC 46 // Executable file format error.

+#define ENOLCK 47 // No locks available.

+#define ENOLINK 48 // Reserved.

+#define ENOMEM 49 // Not enough space.

+#define ENOMSG 50 // No message of the desired type.

+#define ENOPROTOOPT 51 // Protocol not available.

+#define ENOSPC 52 // No space left on device.

+#define ENOSR 53 // No STREAM resources.

+#define ENOSTR 54 // Not a STREAM.

+#define ENOSYS 55 // Functionality not supported.

+#define ENOTCONN 56 // The socket is not connected.

+#define ENOTDIR 57 // Not a directory or a symbolic link to a directory.

+#define ENOTEMPTY 58 // Directory not empty.

+#define ENOTRECOVERABLE 59 // State not recoverable.

+#define ENOTSOCK 60 // Not a socket.

+#define ENOTSUP 61 // Not supported (may be the same value as.

+#define ENOTTY 62 // Inappropriate I/O control operation.

+#define ENXIO 63 // No such device or address.

+#define EOPNOTSUPP ENOTSUP // Operation not supported on socket.

+#define EOVERFLOW 65 // Value too large to be stored in data type.

+#define EOWNERDEAD 66 // Previous owner died.

+#define EPERM 67 // Operation not permitted.

+#define EPIPE 68 // Broken pipe.

+#define EPROTO 69 // Protocol error.

+#define EPROTONOSUPPORT 70 // Protocol not supported.

+#define EPROTOTYPE 71 // Protocol wrong type for socket.

+#define ERANGE 72 // Result too large.

+#define EROFS 73 // Read-only file system.

+#define ESPIPE 74 // Invalid seek.

+#define ESRCH 75 // No such process.

+#define ESTALE 76 // Reserved.

+#define ETIME 77 // Stream ioctl() timeout.

+#define ETIMEDOUT 78 // Connection timed out.

+#define ETXTBSY 79 // Text file busy.

+#define EWOULDBLOCK EAGAIN // Operation would block.

+#define EXDEV 81 // Cross-device link.

+

+extern int errno;

+#endif

+// FIXME: Is there some standard value for this?

+#define O_NONBLOCK (1 << 0)

+#define O_READ (1 << 1)

+#define O_WRITE (1 << 2)

+#define O_CREAT (1 << 3)

+#define O_RDONLY O_READ

+#define O_WRONLY O_WRITE

+#define O_RDWR (O_WRITE | O_READ)

+

+int open(const char *file, int flags, int mode);

+#ifndef ASSERT_H

+#define ASSERT_H

+

+#define assert(expr) \

+ { \

+ if (!(expr)) \

+ aFailed(__FILE__, __LINE__); \

+ }

+void aFailed(char *f, int l);

+#endif

+#ifndef CTYPE_H

+#define CTYPE_H

+

+int isspace(int c);

+int isascii(int c);

+int toupper(int c);

+int tolower(int c);

+int isdigit(int c);

+int isalpha(int c);

+int isxdigit(int c);

+int ispunct(int c);

+int isalnum(int c);

+int isprint(int c);

+#endif

+#ifndef DIRENT_H

+#define DIRENT_H

+#include <fcntl.h>

+#include <limits.h>

+#include <stddef.h>

+#include <stdlib.h>

+#include <sys/types.h>

+#include <unistd.h>

+

+struct dirent {

+ ino_t d_ino; // File serial number.

+ char d_name[PATH_MAX]; // Filename string of entry.

+};

+

+typedef struct {

+ int fd;

+ struct dirent internal_direntry;

+ int dir_num;

+} DIR;

+

+DIR *opendir(const char *dirname);

+struct dirent *readdir(DIR *dir);

+int closedir(DIR *dirp);

+int alphasort(const struct dirent **d1, const struct dirent **d2);

+int scandir(const char *dir, struct dirent ***namelist,

+ int (*sel)(const struct dirent *),

+ int (*compar)(const struct dirent **, const struct dirent **));

+#endif

+#define LITTLE_ENDIAN 0

+#define BYTE_ORDER LITTLE_ENDIAN

+#ifndef ERRNO_H

+#define ERRNO_H

+// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html

+#define E2BIG 1 // Argument list too long.

+#define EACCES 2 // Permission denied.

+#define EADDRINUSE 3 // Address in use.

+#define EADDRNOTAVAIL 4 // Address not available.

+#define EAFNOSUPPORT 5 // Address family not supported.

+#define EAGAIN 6 // Resource unavailable, try again.

+#define EALREADY 7 // Connection already in progress.

+#define EBADF 8 // Bad file descriptor.

+#define EBADMSG 9 // Bad message.

+#define EBUSY 10 // Device or resource busy.

+#define ECANCELED 11 // Operation canceled.

+#define ECHILD 12 // No child processes.

+#define ECONNABORTED 13 // Connection aborted.

+#define ECONNREFUSED 14 // Connection refused.

+#define ECONNRESET 15 // Connection reset.

+#define EDEADLK 16 // Resource deadlock would occur.

+#define EDESTADDRREQ 17 // Destination address required.

+#define EDOM 18 // Mathematics argument out of domain of function.

+#define EDQUOT 19 // Reserved.

+#define EEXIST 20 // File exists.

+#define EFAULT 21 // Bad address.

+#define EFBIG 22 // File too large.

+#define EHOSTUNREACH 23 // Host is unreachable.

+#define EIDRM 24 // Identifier removed.

+#define EILSEQ 25 // Illegal byte sequence.

+#define EINPROGRESS 26 // Operation in progress.

+#define EINTR 27 // Interrupted function.

+#define EINVAL 28 // Invalid argument.

+#define EIO 29 // I/O error.

+#define EISCONN 30 // Socket is connected.

+#define EISDIR 31 // Is a directory.

+#define ELOOP 32 // Too many levels of symbolic links.

+#define EMFILE 33 // File descriptor value too large.

+#define EMLINK 34 // Too many links.

+#define EMSGSIZE 35 // Message too large.

+#define EMULTIHOP 36 // Reserved.

+#define ENAMETOOLONG 37 // Filename too long.

+#define ENETDOWN 38 // Network is down.

+#define ENETRESET 39 // Connection aborted by network.

+#define ENETUNREACH 40 // Network unreachable.

+#define ENFILE 41 // Too many files open in system.

+#define ENOBUFS 42 // No buffer space available.

+#define ENODATA 43 // No message is available on the STREAM head read queue.

+#define ENODEV 44 // No such device.

+#define ENOENT 45 // No such file or directory.

+#define ENOEXEC 46 // Executable file format error.

+#define ENOLCK 47 // No locks available.

+#define ENOLINK 48 // Reserved.

+#define ENOMEM 49 // Not enough space.

+#define ENOMSG 50 // No message of the desired type.

+#define ENOPROTOOPT 51 // Protocol not available.

+#define ENOSPC 52 // No space left on device.

+#define ENOSR 53 // No STREAM resources.

+#define ENOSTR 54 // Not a STREAM.

+#define ENOSYS 55 // Functionality not supported.

+#define ENOTCONN 56 // The socket is not connected.

+#define ENOTDIR 57 // Not a directory or a symbolic link to a directory.

+#define ENOTEMPTY 58 // Directory not empty.

+#define ENOTRECOVERABLE 59 // State not recoverable.

+#define ENOTSOCK 60 // Not a socket.

+#define ENOTSUP 61 // Not supported (may be the same value as.

+#define ENOTTY 62 // Inappropriate I/O control operation.

+#define ENXIO 63 // No such device or address.

+#define EOPNOTSUPP ENOTSUP // Operation not supported on socket.

+#define EOVERFLOW 65 // Value too large to be stored in data type.

+#define EOWNERDEAD 66 // Previous owner died.

+#define EPERM 67 // Operation not permitted.

+#define EPIPE 68 // Broken pipe.

+#define EPROTO 69 // Protocol error.

+#define EPROTONOSUPPORT 70 // Protocol not supported.

+#define EPROTOTYPE 71 // Protocol wrong type for socket.

+#define ERANGE 72 // Result too large.

+#define EROFS 73 // Read-only file system.

+#define ESPIPE 74 // Invalid seek.

+#define ESRCH 75 // No such process.

+#define ESTALE 76 // Reserved.

+#define ETIME 77 // Stream ioctl() timeout.

+#define ETIMEDOUT 78 // Connection timed out.

+#define ETXTBSY 79 // Text file busy.

+#define EWOULDBLOCK EAGAIN // Operation would block.

+#define EXDEV 81 // Cross-device link.

+

+extern int errno;

+#endif

+// FIXME: Is there some standard value for this?

+#define O_NONBLOCK (1 << 0)

+#define O_READ (1 << 1)

+#define O_WRITE (1 << 2)

+#define O_CREAT (1 << 3)

+#define O_TRUNC (1 << 4)

+

+#define O_RDONLY O_READ

+#define O_WRONLY O_WRITE

+#define O_RDWR (O_WRITE | O_READ)

+

+int open(const char *file, int flags, int mode);

+#ifndef GLOB_H

+#define GLOB_H

+#include <stddef.h>

+

+typedef struct {

+ size_t gl_pathc; // Count of paths matched by pattern.

+ char **gl_pathv; // Pointer to a list of matched pathnames

+ size_t gl_offs; // Slots to reserve at the beginning of gl_pathv.

+} glob_t;

+#endif

+#ifndef INPUT_H

+#define INPUT_H

+#include <stdint.h>

+

+struct input_event {

+ uint16_t key;

+ uint8_t status;

+};

+#endif

+#include <stdint.h>

+

+// FIXME: These are not correct

+#define PRId8 "d"

+#define PRId16 "d"

+#define PRId32 "d"

+#define PRId64 "d"

+#define PRIu8 "d"

+#define PRIu16 "d"

+#define PRIu32 "d"

+#define PRIu64 "d"

+#define PRIx8 "x"

+#define PRIx16 "x"

+#define PRIx32 "x"

+#define PRIx64 "x"

+#define PRIX8 "x"

+#define PRIX16 "x"

+#define PRIX32 "x"

+#define PRIX64 "x"

+#ifndef LIBGEN_H

+#define LIBGEN_H

+

+char *basename(char *path);

+char *dirname(char *path);

+#endif

+#define PATH_MAX 256

+#define FILENAME_MAX PATH_MAX

+#define ULONG_MAX 0xFFFFFFFFUL

+#define LONG_MAX 2147483647

+#ifndef POLL_H

+#define POLL_H

+#include <stddef.h>

+

+#define POLLIN (1 << 0)

+#define POLLPRI (1 << 1)

+#define POLLOUT (1 << 2)

+#define POLLHUP (1 << 3)

+

+struct pollfd {

+ int fd;

+ short events;

+ short revents;

+};

+

+int poll(struct pollfd *fds, size_t nfds, int timeout);

+#endif

+#ifndef PTY_H

+#define PTY_H

+int openpty(int *amaster, int *aslave, char *name,

+ /*const struct termios*/ void *termp,

+ /*const struct winsize*/ void *winp);

+#endif

+#ifndef SETJMP_H

+#define SETJMP_H

+typedef unsigned long __jmp_buf[6];

+typedef struct __jmp_buf_tag {

+ __jmp_buf __jb;

+ unsigned long __fl;

+ unsigned long __ss[128/sizeof(long)];

+} jmp_buf[1];

+typedef jmp_buf sigjmp_buf;

+

+void _longjmp(jmp_buf, int);

+void longjmp(jmp_buf, int);

+void siglongjmp(sigjmp_buf, int);

+#endif

+#ifndef SIGNAL_H

+#define SIGNAL_H

+#define SIGHUP 0

+#define SIGINT 1

+#define SIGWINCH 2

+#define SIGQUIT 3

+#define SIG_IGN 4

+typedef int sig_atomic_t;

+#endif // SIGNAL_H

+#include <stddef.h>

+#include <stdint.h>

+

+#define AF_UNIX 0

+#define AF_LOCAL AF_UNIX

+

+#define INADDR_ANY 0

+

+typedef struct {

+ int domain;

+ int type;

+ int protocol;

+

+ // UNIX socket

+ char *path;

+ int incoming_fd;

+} SOCKET;

+

+typedef struct {

+ char *path;

+ SOCKET *s;

+} OPEN_UNIX_SOCKET;

+

+typedef uint32_t in_addr_t;

+typedef uint16_t in_port_t;

+typedef unsigned int sa_family_t;

+typedef uint32_t socklen_t;

+

+struct sockaddr {

+ sa_family_t sa_family; /* Address family */

+ char *sa_data; /* Socket address */

+};

+

+struct sockaddr_un {

+ sa_family_t sun_family; /* Address family */

+ char *sun_path; /* Socket pathname */

+};

+

+int socket(int domain, int type, int protocol);

+int accept(int socket, struct sockaddr *address, socklen_t *address_len);

+int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

+#ifndef STDIO_H

+#define STDIO_H

+#include <stdarg.h>

+#include <stddef.h>

+#include <stdint.h>

+

+// FIXME: Most of these should probably not be here. But I am too lazy

+// to fix it right now. This is futures mees problem to deal wth.

+

+#define EOF (-1)

+

+#define SEEK_SET 0

+#define SEEK_CUR 1

+#define SEEK_END 2

+

+#define BUFSIZ 4096

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/setvbuf.html

+#define _IOFBF 1 // shall cause input/output to be fully buffered.

+#define _IOLBF 2 // shall cause input/output to be line buffered.

+#define _IONBF 3 // shall cause input/output to be unbuffered.

+

+typedef long fpos_t;

+

+typedef struct __IO_FILE FILE;

+struct __IO_FILE {

+ size_t (*write)(FILE *, const unsigned char *, size_t);

+ size_t (*read)(FILE *, unsigned char *, size_t);

+ int (*seek)(FILE *, long, int);

+ long offset_in_file;

+ int buffered_char;

+ int has_buffered_char;

+ int fd;

+ uint8_t is_eof;

+ uint8_t has_error;

+ uint64_t file_size;

+ void *cookie;

+};

+

+size_t write_fd(FILE *f, const unsigned char *s, size_t l);

+size_t read_fd(FILE *f, unsigned char *s, size_t l);

+int seek_fd(FILE *stream, long offset, int whence);

+

+typedef struct {

+ int fd;

+} FILE_FD_COOKIE;

+

+extern FILE __stdin_FILE;

+extern FILE __stdout_FILE;

+extern FILE __stderr_FILE;

+

+#define stdin (&__stdin_FILE)

+#define stdout (&__stdout_FILE)

+//#define stderr (&__stderr_FILE)

+#define stderr (&__stdout_FILE)

+

+typedef int mode_t;

+

+void perror(const char *s);

+

+int putchar(int c);

+int puts(const char *s);

+int brk(void *addr);

+void *sbrk(intptr_t increment);

+int write(int fd, const char *buf, size_t count);

+int pwrite(int fd, const char *buf, size_t count, size_t offset);

+int printf(const char *format, ...);

+int pread(int fd, void *buf, size_t count, size_t offset);

+int read(int fd, void *buf, size_t count);

+int fork(void);

+int memcmp(const void *s1, const void *s2, size_t n);

+int wait(int *stat_loc);

+void exit(int status);

+void *memcpy(void *dest, const void *src, uint32_t n);

+int shm_open(const char *name, int oflag, mode_t mode);

+int dprintf(int fd, const char *format, ...);

+int vdprintf(int fd, const char *format, va_list ap);

+int vprintf(const char *format, va_list ap);

+int snprintf(char *str, size_t size, const char *format, ...);

+int vsnprintf(char *str, size_t size, const char *format, va_list ap);

+int vfprintf(FILE *f, const char *fmt, va_list ap);

+int fgetc(FILE *stream);

+int getchar(void);

+#define getc(_a) fgetc(_a)

+size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

+size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

+FILE *fopen(const char *pathname, const char *mode);

+int fclose(FILE *stream);

+int fseek(FILE *stream, long offset, int whence);

+int fprintf(FILE *f, const char *fmt, ...);

+int atoi(const char *str);

+long strtol(const char *nptr, char **endptr, int base);

+char *strchr(const char *s, int c);

+char *strcat(char *s1, const char *s2);

+char *fgets(char *s, int n, FILE *stream);

+FILE *tmpfile(void);

+int feof(FILE *stream);

+int fscanf(FILE *stream, const char *format, ...);

+int ungetc(int c, FILE *stream);

+long ftell(FILE *stream);

+int fputc(int c, FILE *stream);

+int remove(const char *path);

+int ferror(FILE *stream);

+int fputs(const char *s, FILE *stream);

+int fflush(FILE *stream);

+int setvbuf(FILE *stream, char *restrict buf, int type, size_t size);

+int fileno(FILE *stream);

+int putc(int c, FILE *stream);

+int vsprintf(char *str, const char *format, va_list ap);

+int sprintf(char *str, const char *format, ...);

+FILE *open_memstream(char **bufp, size_t *sizep);

+int fsetpos(FILE *stream, const fpos_t *pos);

+int fgetpos(FILE *restrict stream, fpos_t *restrict pos);

+char *tmpnam(char *s);

+int rename(const char *old, const char *new);

+#endif

+#ifndef STDLIB_H

+#define STDLIB_H

+#include <limits.h>

+#include <stddef.h>

+#define RAND_MAX (UINT32_MAX)

+#define EXIT_SUCCESS 0

+#define EXIT_FAILURE 1

+

+typedef size_t size_t; // only for 32 bit

+

+void *malloc(size_t s);

+void *calloc(size_t nelem, size_t elsize);

+void *realloc(void *ptr, size_t size);

+void free(void *p);

+char *getenv(const char *name);

+int rand(void);

+void srand(unsigned int seed);

+unsigned long strtoul(const char *restrict str, char **restrict endptr,

+ int base);

+long strtol(const char *str, char **restrict endptr, int base);

+void abort(void);

+int abs(int i);

+void qsort(void *base, size_t nel, size_t width,

+ int (*compar)(const void *, const void *));

+int atexit(void (*func)(void));

+int mkstemp(char *template);

+long double strtold(const char *restrict nptr, char **restrict endptr);

+int system(const char *command);

+double atof(const char *str);

+double strtod(const char *restrict nptr, char **restrict endptr);

+int atoi(const char *str);

+#endif

+#ifndef STRING_H

+#define STRING_H

+#include <stddef.h>

+#include <stdint.h>

+

+char *strerror(int errnum);

+void *memset(void *s, int c, size_t n);

+void *memcpy(void *dest, const void *src, uint32_t n);

+int strcmp(const char *s1, const char *s2);

+char *strcpy(char *dest, const char *src);

+size_t strlen(const char *s);

+size_t strnlen(const char *s, size_t maxlen);

+int sscanf(const char *s, const char *restrict format, ...);

+char *strrchr(const char *s, int c);

+int strncmp(const char *s1, const char *s2, size_t n);

+char *strncpy(char *s1, const char *s2, size_t n);

+size_t *strlcpy(char *s1, const char *s2, size_t n);

+size_t strcspn(const char *s1, const char *s2);

+char *strpbrk(const char *s1, const char *s2);

+size_t strspn(const char *s1, const char *s2);

+void *memmove(void *s1, const void *s2, size_t n);

+char *strdup(const char *s);

+char *strndup(const char *s, size_t size);

+char *strstr(const char *s1, const char *s2);

+int strncasecmp(const char *s1, const char *s2, size_t n);

+int strcasecmp(const char *s1, const char *s2);

+char *strtok(char *restrict s, const char *restrict sep);

+char *strcat(char *restrict s1, const char *restrict s2);

+#endif

+#ifndef IOCTL_H

+#define IOCTL_H

+#define TIOCGWINSZ 0

+struct winsize {

+ unsigned short ws_row;

+ unsigned short ws_col;

+ unsigned short ws_xpixel;

+ unsigned short ws_ypixel;

+};

+#endif // IOCTL_H

+#ifndef MMAP_H

+#define MMAP_H

+#include <stdint.h>

+#include <stddef.h>

+

+#define PROT_READ (1 << 0)

+#define PROT_WRITE (1 << 1)

+

+#define MAP_PRIVATE (1 << 0)

+#define MAP_ANONYMOUS (1<< 1)

+#define MAP_SHARED (1<< 2)

+

+void *mmap(void *addr, size_t length, int prot, int flags, int fd,

+ size_t offset);

+#endif

+#ifndef STAT_H

+#define STAT_H

+#include <sys/types.h>

+#include <time.h>

+

+struct stat {

+ dev_t st_dev; // Device ID of device containing file.

+ ino_t st_ino; // File serial number.

+ mode_t st_mode; // Mode of file (see below).

+ nlink_t st_nlink; // Number of hard links to the file.

+ uid_t st_uid; // User ID of file.

+ gid_t st_gid; // Group ID of file.

+ dev_t st_rdev; // Device ID (if file is character or block special).

+ off_t st_size; // For regular files, the file size in bytes.

+ // For symbolic links, the length in bytes of the

+ // pathname contained in the symbolic link.

+ // For a shared memory object, the length in bytes.

+ // For a typed memory object, the length in bytes.

+ // For other file types, the use of this field is

+ // unspecified.

+ struct timespec st_atime; // Last data access timestamp.

+ struct timespec st_mtime; // Last data modification timestamp.

+ struct timespec st_ctime; // Last file status change timestamp.

+ blksize_t st_blksize; // A file system-specific preferred I/O block size

+ // for this object. In some file system types, this

+ // may vary from file to file.

+ blkcnt_t st_blocks; // Number of blocks allocated for this object.

+};

+int stat(const char *path, struct stat *buf);

+int mkdir(const char *path, mode_t mode);

+#endif

+#ifndef TIME_H

+#define TIME_H

+#include <stddef.h>

+#include <sys/types.h>

+#include <time.h>

+

+#define CLOCK_REALTIME 0

+

+struct tm {

+ int tm_sec;

+ int tm_min;

+ int tm_hour;

+ int tm_mday;

+ int tm_mon;

+ int tm_year;

+ int tm_wday;

+ int tm_yday;

+ int tm_isdst;

+ long __tm_gmtoff;

+ const char *__tm_zone;

+};

+

+typedef int clockid_t;

+struct timespec {

+ time_t tv_sec; // Seconds.

+ long tv_nsec; // Nanoseconds.

+};

+

+struct timeval {

+ time_t tv_sec;

+ suseconds_t tv_usec;

+};

+

+time_t time(time_t *tloc);

+int clock_gettime(clockid_t clock_id, struct timespec *tp);

+struct tm *localtime(const time_t *timer);

+struct tm *gmtime(const time_t *timer);

+size_t strftime(char *restrict s, size_t maxsize, const char *restrict format,

+ const struct tm *restrict timeptr);

+int gettimeofday(struct timeval *tp, void *tzp);

+#endif

+#ifndef TYPES_H

+#define TYPES_H

+typedef unsigned int ino_t;

+

+typedef int mode_t;

+

+typedef int nlink_t;

+typedef int uid_t;

+typedef int gid_t;

+typedef int id_t;

+

+typedef int blkcnt_t;

+typedef int off_t;

+

+typedef int dev_t;

+typedef unsigned int fsblkcnt_t;

+typedef unsigned int fsfilcnt_t;

+typedef unsigned int ino_t;

+//typedef unsigned int size_t;

+

+typedef int blksize_t;

+typedef int pid_t;

+typedef int ssize_t;

+

+//typedef int clock_t;

+typedef int time_t;

+typedef unsigned int suseconds_t;

+#endif

+#ifndef SYSCALL_H

+#define SYSCALL_H

+#include "socket.h"

+#include <stddef.h>

+#include <stdint.h>

+#include <sys/types.h>

+

+#define SYS_OPEN 0

+#define SYS_READ 1

+#define SYS_WRITE 2

+#define SYS_PREAD 3

+#define SYS_PWRITE 4

+#define SYS_FORK 5

+#define SYS_EXEC 6

+#define SYS_GETPID 7

+#define SYS_EXIT 8

+#define SYS_WAIT 9

+#define SYS_BRK 10

+#define SYS_SBRK 11

+#define SYS_PIPE 12

+#define SYS_DUP2 13

+#define SYS_CLOSE 14

+#define SYS_OPENPTY 15

+#define SYS_POLL 16

+#define SYS_MMAP 17

+#define SYS_ACCEPT 18

+#define SYS_BIND 19

+#define SYS_SOCKET 20

+#define SYS_SHM_OPEN 21

+#define SYS_FTRUNCATE 22

+#define SYS_STAT 23

+#define SYS_MSLEEP 24

+#define SYS_UPTIME 25

+

+int syscall(uint32_t eax, uint32_t ebx, uint32_t ecx, uint32_t edx,

+ uint32_t esi, uint32_t edi);

+int s_syscall(int sys);

+

+extern int errno;

+#define RC_ERRNO(_rc) \

+ { \

+ int c = _rc; \

+ if (c < 0) { \

+ errno = -(c); \

+ return -1; \

+ } \

+ return c; \

+ }

+

+typedef int mode_t;

+

+typedef struct SYS_OPEN_PARAMS {

+ const char *file;

+ int flags;

+ int mode;

+} __attribute__((packed)) SYS_OPEN_PARAMS;

+

+typedef struct SYS_PREAD_PARAMS {

+ int fd;

+ void *buf;

+ size_t count;

+ size_t offset;

+} __attribute__((packed)) SYS_PREAD_PARAMS;

+

+typedef struct SYS_READ_PARAMS {

+ int fd;

+ void *buf;

+ size_t count;

+} __attribute__((packed)) SYS_READ_PARAMS;

+

+typedef struct SYS_PWRITE_PARAMS {

+ int fd;

+ const void *buf;

+ size_t count;

+ size_t offset;

+} __attribute__((packed)) SYS_PWRITE_PARAMS;

+

+typedef struct SYS_WRITE_PARAMS {

+ int fd;

+ const void *buf;

+ size_t count;

+} __attribute__((packed)) SYS_WRITE_PARAMS;

+

+typedef struct SYS_EXEC_PARAMS {

+ const char *path;

+ char **argv;

+} __attribute__((packed)) SYS_EXEC_PARAMS;

+

+typedef struct SYS_DUP2_PARAMS {

+ int org_fd;

+ int new_fd;

+} __attribute__((packed)) SYS_DUP2_PARAMS;

+

+typedef struct SYS_OPENPTY_PARAMS {

+ int *amaster;

+ int *aslave;

+ char *name;

+ /*const struct termios*/ void *termp;

+ /*const struct winsize*/ void *winp;

+} __attribute__((packed)) SYS_OPENPTY_PARAMS;

+

+typedef struct SYS_POLL_PARAMS {

+ struct pollfd *fds;

+ size_t nfds;

+ int timeout;

+} __attribute__((packed)) SYS_POLL_PARAMS;

+

+typedef struct SYS_MMAP_PARAMS {

+ void *addr;

+ size_t length;

+ int prot;

+ int flags;

+ int fd;

+ size_t offset;

+} __attribute__((packed)) SYS_MMAP_PARAMS;

+

+typedef struct SYS_SOCKET_PARAMS {

+ int domain;

+ int type;

+ int protocol;

+} __attribute__((packed)) SYS_SOCKET_PARAMS;

+

+typedef struct SYS_BIND_PARAMS {

+ int sockfd;

+ const struct sockaddr *addr;

+ socklen_t addrlen;

+} __attribute__((packed)) SYS_BIND_PARAMS;

+

+typedef struct SYS_ACCEPT_PARAMS {

+ int socket;

+ struct sockaddr *address;

+ socklen_t *address_len;

+} __attribute__((packed)) SYS_ACCEPT_PARAMS;

+

+typedef struct SYS_SHM_OPEN_PARAMS {

+ const char *name;

+ int oflag;

+ mode_t mode;

+} __attribute__((packed)) SYS_SHM_OPEN_PARAMS;

+

+typedef struct SYS_FTRUNCATE_PARAMS {

+ int fildes;

+ size_t length;

+} __attribute__((packed)) SYS_FTRUNCATE_PARAMS;

+

+typedef struct SYS_STAT_PARAMS {

+ const char *pathname;

+ struct stat *statbuf;

+} __attribute__((packed)) SYS_STAT_PARAMS;

+#endif

+#ifndef TIME_H

+#define TIME_H

+#include <sys/types.h>

+#include <stddef.h>

+

+#define CLOCK_REALTIME 0

+

+struct tm {

+ int tm_sec;

+ int tm_min;

+ int tm_hour;

+ int tm_mday;

+ int tm_mon;

+ int tm_year;

+ int tm_wday;

+ int tm_yday;

+ int tm_isdst;

+ long __tm_gmtoff;

+ const char *__tm_zone;

+};

+

+typedef int clockid_t;

+struct timespec {

+ time_t tv_sec; // Seconds.

+ long tv_nsec; // Nanoseconds.

+};

+

+time_t time(time_t *tloc);

+int clock_gettime(clockid_t clock_id, struct timespec *tp);

+struct tm *localtime(const time_t *timer);

+struct tm *gmtime(const time_t *timer);

+size_t strftime(char *restrict s, size_t maxsize,

+ const char *restrict format, const struct tm *restrict timeptr);

+char *ctime_r(const time_t *clock, char *buf);

+#endif

+#include <stdint.h>

+

+enum { type_kind_int = 0, type_kind_float = 1, type_unknown = 0xffff };

+

+struct type_descriptor {

+ uint16_t type_kind;

+ uint16_t type_info;

+ char type_name[1];

+};

+

+struct source_location {

+ const char *file_name;

+ union {

+ unsigned long reported;

+ struct {

+ uint32_t line;

+ uint32_t column;

+ };

+ };

+};

+

+struct OverflowData {

+ struct source_location location;

+ struct type_descriptor *type;

+};

+

+struct type_mismatch_data {

+ struct source_location location;

+ struct type_descriptor *type;

+ unsigned long alignment;

+ unsigned char type_check_kind;

+};

+

+struct type_mismatch_data_v1 {

+ struct source_location location;

+ struct type_descriptor *type;

+ unsigned char log_alignment;

+ unsigned char type_check_kind;

+};

+

+struct type_mismatch_data_common {

+ struct source_location *location;

+ struct type_descriptor *type;

+ unsigned long alignment;

+ unsigned char type_check_kind;

+};

+

+struct nonnull_arg_data {

+ struct source_location location;

+ struct source_location attr_location;

+ int arg_index;

+};

+

+struct OutOfBoundsData {

+ struct source_location location;

+ struct type_descriptor *array_type;

+ struct type_descriptor *index_type;

+};

+

+struct ShiftOutOfBoundsData {

+ struct source_location location;

+ struct type_descriptor *lhs_type;

+ struct type_descriptor *rhs_type;

+};

+

+struct unreachable_data {

+ struct source_location location;

+};

+

+struct invalid_value_data {

+ struct source_location location;

+ struct type_descriptor *type;

+};

+

+struct alignment_assumption_data {

+ struct source_location location;

+ struct source_location assumption_location;

+ struct type_descriptor *type;

+};

+#ifndef UNISTD_H

+#define UNISTD_H

+#include <stddef.h>

+#include <stdint.h>

+#include <sys/types.h>

+

+#define STDIN_FILENO 0

+

+extern int opterr, optind, optopt;

+extern char *optarg;

+

+int close(int fildes);

+int ftruncate(int fildes, uint64_t length);

+int execv(char *path, char **argv);

+int pipe(int fd[2]);

+int dup2(int org_fd, int new_fd);

+int getopt(int argc, char *const argv[], const char *optstring);

+pid_t getpid(void);

+int unlink(const char *path);

+int execvp(const char *file, char *const argv[]);

+void _exit(int status);

+void msleep(uint32_t ms); // not standard

+uint32_t uptime(void); // not standard

+#endif

+#ifndef INPUT_H

+#define INPUT_H

+#include <stdint.h>

+

+struct input_event {

+ uint16_t key;

+ uint8_t status;

+};

+#endif

+#include <stdint.h>

+

+// FIXME: These are not correct

+#define PRId64 "d"

+#define PRId32 "d"

+#include <ctype.h>

+

+int isspace(int c) {

+ return c == ' ' || (unsigned)c-'\t' < 5;

+}

+#include <assert.h>

+#include <errno.h>

+#include <stdio.h>

+#include <string.h>

+#include <syscall.h>

+

+int errno;

+

+char *errno_strings[] = {

+ "",

+ "Argument list too long.",

+ "Permission denied.",

+ "Address in use.",

+ "Address not available.",

+ "Address family not supported.",

+ "Resource unavailable, try again (may be the same value as [EWOULDBLOCK]).",

+ "Connection already in progress.",

+ "Bad file descriptor.",

+ "Bad message.",

+ "Device or resource busy.",

+ "Operation canceled.",

+ "No child processes.",

+ "Connection aborted.",

+ "Connection refused.",

+ "Connection reset.",

+ "Resource deadlock would occur.",

+ "Destination address required.",

+ "Mathematics argument out of domain of function.",

+ "Reserved.",

+ "File exists.",

+ "Bad address.",

+ "File too large.",

+ "Host is unreachable.",

+ "Identifier removed.",

+ "Illegal byte sequence.",

+ "Operation in progress.",

+ "Interrupted function.",

+ "Invalid argument.",

+ "I/O error.",

+ "Socket is connected.",

+ "Is a directory.",

+ "Too many levels of symbolic links.",

+ "File descriptor value too large.",

+ "Too many links.",

+ "Message too large.",

+ "Reserved.",

+ "Filename too long.",

+ "Network is down.",

+ "Connection aborted by network.",

+ "Network unreachable.",

+ "Too many files open in system.",

+ "No buffer space available.",

+ "No message is available on the STREAM head read "

+ "queue. [Option End]",

+ "No such device.",

+ "No such file or directory.",

+ "Executable file format error.",

+ "No locks available.",

+ "Reserved.",

+ "Not enough space.",

+ "No message of the desired type.",

+ "Protocol not available.",

+ "No space left on device.",

+ "No STREAM resources.",

+ "Not a STREAM.",

+ "Functionality not supported.",

+ "The socket is not connected.",

+ "Not a directory or a symbolic link to a directory.",

+ "Directory not empty.",

+ "State not recoverable.",

+ "Not a socket.",

+ "Not supported (may be the same value as [EOPNOTSUPP]).",

+ "Inappropriate I/O control operation.",

+ "No such device or address.",

+ "Operation not supported on socket (may be the same value as [ENOTSUP]).",

+ "Value too large to be stored in data type.",

+ "Previous owner died.",

+ "Operation not permitted.",

+ "Broken pipe.",

+ "Protocol error.",

+ "Protocol not supported.",

+ "Protocol wrong type for socket.",

+ "Result too large.",

+ "Read-only file system.",

+ "Invalid seek.",

+ "No such process.",

+ "Reserved.",

+ "Stream ioctl() timeout. [Option End]",

+ "Connection timed out.",

+ "Text file busy.",

+ "Operation would block (may be the same value as [EAGAIN]).",

+ "Cross-device link. ",

+};

+

+#define ASSERT_NOT_REACHED assert(0)

+

+#define TAB_SIZE 8

+

+// Functions preserve the registers ebx, esi, edi, ebp, and esp; while

+// eax, ecx, edx are scratch registers.

+

+// Syscall: eax ebx ecx edx esi edi

+int syscall(uint32_t eax, uint32_t ebx, uint32_t ecx, uint32_t edx,

+ uint32_t esi, uint32_t edi) {

+ asm volatile("push %edi\n"

+ "push %esi\n"

+ "push %ebx\n"

+ "mov 0x1C(%ebp), %edi\n"

+ "mov 0x18(%ebp), %esi\n"

+ "mov 0x14(%ebp), %edx\n"

+ "mov 0x10(%ebp), %ecx\n"

+ "mov 0xc(%ebp), %ebx\n"

+ "mov 0x8(%ebp), %eax\n"

+ "int $0x80\n"

+ "pop %ebx\n"

+ "pop %esi\n"

+ "pop %edi\n");

+}

+

+int pipe(int fd[2]) { return syscall(SYS_PIPE, fd, 0, 0, 0, 0); }

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/strerror.html

+char *strerror(int errnum) {

+ // The strerror() function shall map the error number in errnum to a

+ // locale-dependent error message string and shall return a pointer to it.

+ return errno_strings[errnum];

+}

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/perror.html

+void perror(const char *s) {

+ // The perror() function shall map the error number accessed through the

+ // symbol errno to a language-dependent error message, which shall be written

+ // to the standard error stream as follows:

+

+ // (First (if s is not a null pointer and the character pointed to

+ // by s is not the null byte),

+ if (s && *s != '\0') {

+ // the string pointed to by s

+ // followed by a <colon> and a <space>.

+ printf("%s: ", s);

+ }

+

+ // Then an error message string followed by a <newline>.

+ // The contents of the error message strings shall be the same as those

+ // returned by strerror() with argument errno.

+ printf("%s\n", strerror(errno));

+}

+

+int open(const char *file, int flags, int mode) {

+ struct SYS_OPEN_PARAMS args = {

+ .file = file,

+ .flags = flags,

+ .mode = mode,

+ };

+ RC_ERRNO(syscall(SYS_OPEN, &args, 0, 0, 0, 0));

+}

+

+int close(int fd) { return syscall(SYS_CLOSE, (void *)fd, 0, 0, 0, 0); }

+

+int execv(char *path, char **argv) {

+ struct SYS_EXEC_PARAMS args = {.path = path, .argv = argv};

+ return syscall(SYS_EXEC, &args, 0, 0, 0, 0);

+}

+/*

+int syscall(int sys, void *args) {

+ asm volatile("push %ebx\n"

+ "mov 0xc(%ebp), %ebx\n"

+ "mov 0x8(%ebp), %eax\n"

+ "int $0x80\n"

+ "pop %ebx\n");

+}*/

+

+int s_syscall(int sys) {

+ asm volatile("movl %0, %%eax\n"

+ "int $0x80\n" ::"r"((uint32_t)sys));

+}

+

+int write(int fd, const char *buf, size_t count) {

+ /*

+ struct SYS_WRITE_PARAMS args = {

+ .fd = fd,

+ .buf = buf,

+ .count = count,

+ };*/

+ return syscall(SYS_WRITE, fd, buf, count, 0, 0);

+}

+

+int pwrite(int fd, const char *buf, size_t count, size_t offset) {

+ struct SYS_PWRITE_PARAMS args = {

+ .fd = fd,

+ .buf = buf,

+ .count = count,

+ .offset = offset,

+ };

+ return syscall(SYS_PWRITE, &args, 0, 0, 0, 0);

+}

+

+int wait(int *stat_loc) { return syscall(SYS_WAIT, stat_loc, 0, 0, 0, 0); }

+

+void exit(int status) { syscall(SYS_EXIT, (void *)status, 0, 0, 0, 0); }

+

+int pread(int fd, void *buf, size_t count, size_t offset) {

+ struct SYS_PREAD_PARAMS args = {

+ .fd = fd,

+ .buf = buf,

+ .count = count,

+ .offset = offset,

+ };

+ RC_ERRNO(syscall(SYS_PREAD, &args, 0, 0, 0, 0));

+}

+

+int read(int fd, void *buf, size_t count) {

+ struct SYS_READ_PARAMS args = {

+ .fd = fd,

+ .buf = buf,

+ .count = count,

+ };

+ RC_ERRNO(syscall(SYS_READ, &args, 0, 0, 0, 0));

+}

+

+int dup2(int org_fd, int new_fd) {

+ struct SYS_DUP2_PARAMS args = {

+ .org_fd = org_fd,

+ .new_fd = new_fd,

+ };

+ RC_ERRNO(syscall(SYS_DUP2, &args, 0, 0, 0, 0));

+}

+

+int fork(void) { return s_syscall(SYS_FORK); }

+

+void dputc(int fd, const char c) { pwrite(fd, &c, 1, 0); }

+

+int brk(void *addr) { return syscall(SYS_BRK, addr, 0, 0, 0, 0); }

+

+void *sbrk(intptr_t increment) {

+ return (void *)syscall(SYS_SBRK, (void *)increment, 0, 0, 0, 0);

+}

+

+int poll(struct pollfd *fds, size_t nfds, int timeout) {

+ SYS_POLL_PARAMS args = {

+ .fds = fds,

+ .nfds = nfds,

+ .timeout = timeout,

+ };

+ RC_ERRNO(syscall(SYS_POLL, &args, 0, 0, 0, 0));

+}

+

+int socket(int domain, int type, int protocol) {

+ SYS_SOCKET_PARAMS args = {

+ .domain = domain,

+ .type = type,

+ .protocol = protocol,

+ };

+ RC_ERRNO(syscall(SYS_SOCKET, &args, 0, 0, 0, 0));

+}

+

+int accept(int socket, struct sockaddr *address, socklen_t *address_len) {

+ SYS_ACCEPT_PARAMS args = {

+ .socket = socket,

+ .address = address,

+ .address_len = address_len,

+ };

+ RC_ERRNO(syscall(SYS_ACCEPT, &args, 0, 0, 0, 0));

+}

+

+int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {

+ SYS_BIND_PARAMS args = {

+ .sockfd = sockfd,

+ .addr = addr,

+ .addrlen = addrlen,

+ };

+ RC_ERRNO(syscall(SYS_BIND, &args, 0, 0, 0, 0));

+}

+

+int shm_open(const char *name, int oflag, mode_t mode) {

+ SYS_SHM_OPEN_PARAMS args = {

+ .name = name,

+ .oflag = oflag,

+ .mode = mode,

+ };

+ RC_ERRNO(syscall(SYS_SHM_OPEN, &args, 0, 0, 0, 0));

+}

+

+int ftruncate(int fildes, uint64_t length) {

+ SYS_FTRUNCATE_PARAMS args = {.fildes = fildes, .length = length};

+ RC_ERRNO(syscall(SYS_FTRUNCATE, &args, 0, 0, 0, 0));

+}

+#include <libgen.h>

+#include <stddef.h>

+

+/*

+The basename() function shall take the pathname pointed to by path and

+return a pointer to the final component of the pathname, deleting any

+trailing '/' characters.

+

+

+The basename() function may modify the string pointed to by path, and

+may return a pointer to internal storage. The returned pointer might be

+invalidated or the storage might be overwritten by a subsequent call to

+basename(). The returned pointer might also be invalidated if the

+calling thread is terminated.

+*/

+

+char *basename_empty_return_value = ".";

+char *basename_slash_return_value = "/";

+char *basename(char *path) {

+ // If path is a null pointer or points to an empty string, basename()

+ // shall return a pointer to the string ".".

+ if (NULL == path || '\0' == *path)

+ return basename_empty_return_value;

+

+ char *start = path;

+ // Move the string to the end

+ for (; *path; path++)

+ ;

+ if (start == path)

+ return start;

+ path--;

+ if ('/' == *path) // Trailing slash

+ *path = '\0';

+ // Loop until next slash is found

+ for (; path != start && '/' != *path; path--)

+ ;

+ // If the string pointed to by path consists entirely of the '/' character,

+ // basename() shall return a pointer to the string "/". If the string

+ // pointed to by path is exactly "//", it is implementation-defined whether

+ //'/' or "//" is returned.

+ path++;

+ if ('\0' == *path)

+ return basename_slash_return_value;

+ return path;

+}

+#include <libgen.h>

+

+char *dirname_empty_return_value = ".";

+char *dirname_slash_return_value = "/";

+char *dirname(char *path) {

+ // If path is a null pointer or points to an empty string,

+ // dirname() shall return a pointer to the string "."

+ if (!path)

+ return dirname_empty_return_value;

+ if ('\0' == *path)

+ return dirname_empty_return_value;

+

+ char *start = path;

+ for (; *path; path++)

+ ;

+ path--;

+ if ('/' == *path) {

+ if (start == path)

+ return path;

+ path--;

+ }

+

+ for (; path != start && '/' != *path; path--)

+ ;

+ // If path does not contain a '/', then dirname() shall return a pointer to

+ // the string ".".

+ if ('/' != *path)

+ return dirname_empty_return_value;

+

+ if (path == start)

+ return dirname_slash_return_value;

+

+ *path = '\0';

+ path--;

+

+ for (; path != start && '/' != *path; path--)

+ ;

+

+ if ('/' != *path)

+ return dirname_empty_return_value;

+

+ path++;

+ return path;

+}

+#define PATH_MAX 256

+#define FILENAME_MAX PATH_MAX

+#include <assert.h>

+#include <errno.h>

+#include <malloc/malloc.h>

+#include <stddef.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <string.h>

+#include <unistd.h>

+

+#define NEW_ALLOC_SIZE 0x20000

+#define MALLOC_HEADER_MAGIC 0x1337F00D

+#define MALLOC_HEADER_PAD 0x11223344

+

+#define IS_FREE (1 << 0)

+#define IS_FINAL (1 << 1)

+

+typedef struct MallocHeader {

+ uint32_t magic;

+ uint32_t size;

+ uint8_t flags;

+ struct MallocHeader *n;

+} MallocHeader;

+

+size_t max(size_t a, size_t b) { return (a > b) ? a : b; }

+

+//;size_t min(size_t a, size_t b) { return (a < b) ? a : b; }

+

+uint64_t delta_page(uint64_t a) { return 0x1000 - (a % 0x1000); }

+

+MallocHeader *head = NULL;

+MallocHeader *final = NULL;

+uint32_t total_heap_size = 0;

+

+int init_heap(void) {

+ head = (MallocHeader *)sbrk(NEW_ALLOC_SIZE);

+ if ((void *)-1 == head) {

+ perror("sbrk");

+ exit(1);

+ }

+ total_heap_size += NEW_ALLOC_SIZE - sizeof(MallocHeader);

+ head->magic = MALLOC_HEADER_MAGIC;

+ head->size = NEW_ALLOC_SIZE - sizeof(MallocHeader);

+ head->flags = IS_FREE | IS_FINAL;

+ head->n = NULL;

+ final = head;

+ return 1;

+}

+

+int add_heap_memory(size_t min_desired) {

+ min_desired += sizeof(MallocHeader) + 0x1000;

+ size_t allocation_size = max(min_desired, NEW_ALLOC_SIZE);

+ allocation_size += delta_page(allocation_size);

+ void *p;

+ if ((void *)(-1) == (p = (void *)sbrk(allocation_size))) {

+ perror("sbrk");

+ return 0;

+ }

+ total_heap_size += allocation_size - sizeof(MallocHeader);

+ void *e = final;

+ e = (void *)((uint32_t)e + final->size);

+ if (p == e) {

+ final->size += allocation_size - sizeof(MallocHeader);

+ return 1;

+ }

+ MallocHeader *new_entry = p;

+ new_entry->magic = MALLOC_HEADER_MAGIC;

+ new_entry->size = allocation_size - sizeof(MallocHeader);

+ new_entry->flags = IS_FREE | IS_FINAL;

+ new_entry->n = NULL;

+ final->n = new_entry;

+ final = new_entry;

+ return 1;

+}

+

+MallocHeader *next_header(MallocHeader *a) { return a->n; }

+

+MallocHeader *next_close_header(MallocHeader *a) {

+ if (!a) {

+ printf("next close header fail\n");

+ for (;;)

+ ;

+ }

+ if (a->flags & IS_FINAL)

+ return NULL;

+ return next_header(a);

+}

+

+MallocHeader *find_free_entry(uint32_t s, int align) {

+ // A new header is required as well as the newly allocated chunk

+ if (!head)

+ init_heap();

+ MallocHeader *p = head;

+ for (; p; p = next_header(p)) {

+ if (!(p->flags & IS_FREE))

+ continue;

+ uint64_t required_size = s;

+ if (align) {

+ void *addy = p;

+ addy = (void *)((uint32_t)addy + sizeof(MallocHeader));

+ uint64_t d = delta_page((uint32_t)addy);

+ if (d < sizeof(MallocHeader) && d != 0)

+ continue;

+ required_size += d;

+ }

+ if (p->size < required_size)

+ continue;

+ return p;

+ }

+ return NULL;

+}

+

+void merge_headers(MallocHeader *b) {

+ if (!(b->flags & IS_FREE))

+ return;

+

+ MallocHeader *n = next_close_header(b);

+ if (!n)

+ return;

+

+ if (n > 0xf58c0820 - 0x8 && n < 0xf58c0820 + 0x8) {

+ printf("b: %x\n", b);

+ printf("b->n: %x\n", b->n);

+ asm("hlt");

+ assert(0);

+ }

+ if (!(n->flags & IS_FREE))

+ return;

+

+ // Remove the next header and just increase the newly freed header

+ b->size += n->size;

+ b->flags |= n->flags & IS_FINAL;

+ b->n = n->n;

+ if (n == final)

+ final = b;

+}

+

+extern int errno;

+// https://pubs.opengroup.org/onlinepubs/9699919799/

+void *int_malloc(size_t s, int align) {

+ if (!head)

+ init_heap();

+ size_t n = s;

+ MallocHeader *free_entry = find_free_entry(s, align);

+ if (!free_entry) {

+ if (!add_heap_memory(s)) {

+ errno = ENOMEM;

+ printf("ENOMEM\n");

+ return NULL;

+ }

+ return int_malloc(s, align);

+ }

+

+ void *rc = (void *)((uint32_t)free_entry + sizeof(MallocHeader));

+

+ if (align) {

+ uint64_t d = delta_page((uint32_t)rc);

+ n = d;

+ n -= sizeof(MallocHeader);

+ }

+

+ // Create a new header

+ MallocHeader *new_entry =

+ (MallocHeader *)((uint32_t)free_entry + n + sizeof(MallocHeader));

+ new_entry->magic = MALLOC_HEADER_MAGIC;

+ new_entry->flags = free_entry->flags;

+ new_entry->n = free_entry->n;

+ new_entry->size = free_entry->size - n - sizeof(MallocHeader);

+ if (free_entry == final)

+ final = new_entry;

+ merge_headers(new_entry);

+

+ // Modify the free entry

+ free_entry->size = n;

+ free_entry->flags = 0;

+ free_entry->n = new_entry;

+

+ if (align && ((uint32_t)rc % 0x1000) != 0) {

+ void *c = int_malloc(s, 1);

+ free(rc);

+ rc = c;

+ return rc;

+ }

+ return rc;

+}

+

+void *malloc(size_t s) { return int_malloc(s + 1, 0); }

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/

+void *calloc(size_t nelem, size_t elsize) {

+ // The calloc() function shall allocate unused space for an array of

+ // nelem elements each of whose size in bytes is elsize.

+ size_t alloc_size = nelem * elsize;

+ void *rc = malloc(alloc_size);

+ // The space shall be initialized to all bits 0.

+ memset(rc, 0, alloc_size);

+ return rc;

+}

+

+size_t get_mem_size(void *ptr) {

+ if (!ptr)

+ return 0;

+ return ((MallocHeader *)(ptr - sizeof(MallocHeader)))->size;

+}

+

+void *realloc(void *ptr, size_t size) {

+ void *rc = malloc(size);

+ if (!rc)

+ return NULL;

+ size_t l = get_mem_size(ptr);

+ size_t to_copy = min(l, size);

+ memcpy(rc, ptr, to_copy);

+ free(ptr);

+ return rc;

+}

+

+void free(void *p) {

+ if (!p)

+ return;

+ // FIXME: This assumes that p is at the start of a allocated area.

+ // Is this a assumption that can be made?

+ MallocHeader *h = (MallocHeader *)((uint32_t)p - sizeof(MallocHeader));

+ if (MALLOC_HEADER_MAGIC != h->magic) {

+ printf("h->magic: %x\n", h->magic);

+ printf("&h->magic: %x\n", &(h->magic));

+ assert(0);

+ }

+ if (h->flags & IS_FREE)

+ return;

+

+ h->flags |= IS_FREE;

+ merge_headers(h);

+}

+#ifndef MALLOC_H

+#define MALLOC_H

+#include <stdint.h>

+#include <stddef.h>

+

+void *malloc(size_t s);

+void *calloc(size_t nelem, size_t elsize);

+void free(void *p);

+#endif

+#include "stdio.h"

+#include "stdlib.h"

+#include "../errno.h"

+#include <stdint.h>

+#include <stddef.h>

+#include <string.h>

+

+#define NEW_ALLOC_SIZE 0x1000

+

+#define IS_FREE (1 << 0)

+#define IS_FINAL (1 << 1)

+

+typedef struct MallocHeader {

+ uint32_t size;

+ uint8_t flags;

+} MallocHeader;

+

+MallocHeader *head = NULL;

+MallocHeader *final = NULL;

+uint32_t total_heap_size = 0;

+

+int init_heap(void) {

+ head = sbrk(NEW_ALLOC_SIZE);

+ if ((void *)-1 == head) {

+ // perror("sbrk");

+ return 0;

+ }

+ total_heap_size += NEW_ALLOC_SIZE;

+ head->size = NEW_ALLOC_SIZE;

+ head->flags = IS_FREE | IS_FINAL;

+ final = head;

+ return 1;

+}

+

+int add_heap_memory(void) {

+ if ((void *)-1 == sbrk(NEW_ALLOC_SIZE)) {

+ // perror("sbrk");

+ return 0;

+ }

+ total_heap_size += NEW_ALLOC_SIZE;

+ final->size += NEW_ALLOC_SIZE;

+ return 1;

+}

+

+MallocHeader *next_header(MallocHeader *a) {

+ if (a->flags & IS_FINAL)

+ return NULL;

+ return ((void *)a) + a->size;

+}

+

+MallocHeader *find_free_entry(uint32_t s) {

+ // A new header is required as well as the newly allocated chunk

+ s += sizeof(MallocHeader);

+ if (!head)

+ init_heap();

+ MallocHeader *p = head;

+ for (; p; p = next_header(p)) {

+ if (!(p->flags & IS_FREE))

+ continue;

+ if (p->size < s)

+ continue;

+ return p;

+ }

+ return NULL;

+}

+

+void merge_headers(MallocHeader *b) {

+ if (!(b->flags & IS_FREE))

+ return;

+

+ MallocHeader *n = next_header(b);

+ if (!n)

+ return;

+

+ if (!(n->flags & IS_FREE))

+ return;

+

+ // Remove the next header and just increase the newly freed header

+ b->size += n->size;

+ b->flags |= n->flags & IS_FINAL;

+ if (b->flags & IS_FINAL)

+ final = b;

+}

+

+extern int errno;

+// https://pubs.opengroup.org/onlinepubs/9699919799/

+void *malloc(size_t s) {

+ if(s == 0)

+ s = 1;

+

+ MallocHeader *free_entry = find_free_entry(s);

+ if (!free_entry) {

+ if (!add_heap_memory()) {

+ errno = ENOMEM;

+ return NULL;

+ }

+ return malloc(s);

+ }

+

+ // Create a new header

+ MallocHeader *new_entry = ((void *)free_entry) + s;

+ new_entry->flags |= IS_FREE;

+ new_entry->size = free_entry->size - s - sizeof(MallocHeader);

+ new_entry->flags |= free_entry->flags & IS_FINAL;

+ if (new_entry->flags & IS_FINAL)

+ final = new_entry;

+ merge_headers(new_entry);

+

+ // Modify the free entry

+ free_entry->size = s;

+ free_entry->flags = 0;

+

+ return ((void *)free_entry) + sizeof(MallocHeader);

+}

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/

+void *calloc(size_t nelem, size_t elsize) {

+ // The calloc() function shall allocate unused space for an array of

+ // nelem elements each of whose size in bytes is elsize.

+ size_t alloc_size = nelem*elsize;

+ void *rc = malloc(alloc_size);

+ // The space shall be initialized to all bits 0.

+ memset(rc, 0, alloc_size);

+ return rc;

+}

+

+void free(void *p) {

+ // FIXME: This assumes that p is at the start of a allocated area.

+ // Is this a assumption that can be made?

+ MallocHeader *h = p - sizeof(MallocHeader);

+ if (h->flags & IS_FREE)

+ return;

+

+ h->flags |= IS_FREE;

+ merge_headers(h);

+}

+#include <stddef.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/

+void *memset(void *s, int c, size_t n) {

+ // The memset() function shall copy c (converted to an unsigned

+ // char) into each of the first n bytes of the object pointed to by

+ // s.

+

+ unsigned char *p = s;

+ for (; n > 0; n--, p++)

+ *p = (unsigned char)c;

+

+ // The memset() function shall return s

+ return s;

+}

+#include <syscall.h>

+#include <errno.h>

+#include <sys/mman.h>

+

+extern int errno;

+

+void *mmap(void *addr, size_t length, int prot, int flags, int fd,

+ size_t offset) {

+ SYS_MMAP_PARAMS args = {

+ .addr = addr,

+ .length = length,

+ .prot = prot,

+ .flags = flags,

+ .fd = fd,

+ .offset = offset,

+ };

+// return (void*)syscall(SYS_MMAP, &args);

+ RC_ERRNO(syscall(SYS_MMAP, &args));

+}

+#ifndef POLL_H

+#define POLL_H

+#include <stddef.h>

+

+#define POLLIN (1 << 0)

+#define POLLPRI (1 << 1)

+#define POLLOUT (1 << 2)

+

+struct pollfd {

+ int fd;

+ short events;

+ short revents;

+};

+

+int poll(struct pollfd *fds, size_t nfds, int timeout);

+#endif

+#include "pty.h"

+#include "syscall.h"

+

+int openpty(int *amaster, int *aslave, char *name,

+ /*const struct termios*/ void *termp,

+ /*const struct winsize*/ void *winp) {

+ SYS_OPENPTY_PARAMS args = {

+ .amaster = amaster,

+ .aslave = aslave,

+ .name = name,

+ .termp = termp,

+ .winp = winp,

+ };

+ syscall(SYS_OPENPTY, &args, 0, 0, 0, 0);

+}

+#ifndef PTY_H

+#define PTY_H

+int openpty(int *amaster, int *aslave, char *name,

+ /*const struct termios*/ void *termp,

+ /*const struct winsize*/ void *winp);

+#endif

+.global _longjmp

+.global longjmp

+.type _longjmp,@function

+.type longjmp,@function

+_longjmp:

+longjmp:

+ mov 4(%esp),%edx

+ mov 8(%esp),%eax

+ cmp $1,%eax

+ adc $0, %al

+ mov (%edx),%ebx

+ mov 4(%edx),%esi

+ mov 8(%edx),%edi

+ mov 12(%edx),%ebp

+ mov 16(%edx),%esp

+ jmp *20(%edx)

+.global ___setjmp

+.hidden ___setjmp

+.global __setjmp

+.global _setjmp

+.global setjmp

+.type __setjmp,@function

+.type _setjmp,@function

+.type setjmp,@function

+___setjmp:

+__setjmp:

+_setjmp:

+setjmp:

+ mov 4(%esp), %eax

+ mov %ebx, (%eax)

+ mov %esi, 4(%eax)

+ mov %edi, 8(%eax)

+ mov %ebp, 12(%eax)

+ lea 4(%esp), %ecx

+ mov %ecx, 16(%eax)

+ mov (%esp), %ecx

+ mov %ecx, 20(%eax)

+ xor %eax, %eax

+ ret

+#include <stddef.h>

+#include <stdint.h>

+

+#define AF_UNIX 0

+#define AF_LOCAL AF_UNIX

+

+#define INADDR_ANY 0

+

+typedef struct {

+ int domain;

+ int type;

+ int protocol;

+

+ // UNIX socket

+ char *path;

+ int incoming_fd;

+} SOCKET;

+

+typedef struct {

+ char *path;

+ SOCKET *s;

+} OPEN_UNIX_SOCKET;

+

+typedef uint32_t in_addr_t;

+typedef uint16_t in_port_t;

+typedef unsigned int sa_family_t;

+typedef uint32_t socklen_t;

+

+struct sockaddr {

+ sa_family_t sa_family; /* Address family */

+ char *sa_data; /* Socket address */

+};

+

+struct sockaddr_un {

+ sa_family_t sun_family; /* Address family */

+ char *sun_path; /* Socket pathname */

+};

+

+int socket(int domain, int type, int protocol);

+int accept(int socket, struct sockaddr *address, socklen_t *address_len);

+int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

+#ifndef STDIO_H

+#define STDIO_H

+#include <stdarg.h>

+#include <stddef.h>

+#include <stdint.h>

+

+// FIXME: Most of these should probably not be here. But I am too lazy

+// to fix it right now. This is futures mees problem to deal wth.

+

+#define EOF (-1)

+

+#define SEEK_SET 0

+#define SEEK_CUR 1

+#define SEEK_END 2

+

+typedef struct __IO_FILE FILE;

+struct __IO_FILE {

+ size_t (*write)(FILE *, const unsigned char *, size_t);

+ size_t (*read)(FILE *, unsigned char *, size_t);

+ int (*seek)(FILE *, long, int);

+ long offset_in_file;

+ int buffered_char;

+ int has_buffered_char;

+ uint8_t is_eof;

+ uint8_t has_error;

+ uint64_t file_size;

+ void *cookie;

+};

+

+size_t write_fd(FILE *f, const unsigned char *s, size_t l);

+size_t read_fd(FILE *f, unsigned char *s, size_t l);

+int seek_fd(FILE *stream, long offset, int whence);

+

+typedef struct {

+ int fd;

+} FILE_FD_COOKIE;

+

+extern FILE __stdin_FILE;

+extern FILE __stdout_FILE;

+extern FILE __stderr_FILE;

+

+#define stdin (&__stdin_FILE)

+#define stdout (&__stdout_FILE)

+//#define stderr (&__stderr_FILE)

+#define stderr (&__stdout_FILE)

+

+typedef int mode_t;

+

+void perror(const char *s);

+

+int putchar(int c);

+int puts(const char *s);

+int brk(void *addr);

+void *sbrk(intptr_t increment);

+int write(int fd, const char *buf, size_t count);

+int pwrite(int fd, const char *buf, size_t count, size_t offset);

+int printf(const char *format, ...);

+int pread(int fd, void *buf, size_t count, size_t offset);

+int read(int fd, void *buf, size_t count);

+int fork(void);

+int memcmp(const void *s1, const void *s2, size_t n);

+int wait(int *stat_loc);

+void exit(int status);

+void *memcpy(void *dest, const void *src, uint32_t n);

+int shm_open(const char *name, int oflag, mode_t mode);

+int dprintf(int fd, const char *format, ...);

+int vdprintf(int fd, const char *format, va_list ap);

+int vprintf(const char *format, va_list ap);

+int snprintf(char *str, size_t size, const char *format, ...);

+int vsnprintf(char *str, size_t size, const char *format, va_list ap);

+int vfprintf(FILE *f, const char *fmt, va_list ap);

+int fgetc(FILE *stream);

+int getchar(void);

+#define getc(_a) fgetc(_a)

+size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

+size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

+FILE *fopen(const char *pathname, const char *mode);

+int fclose(FILE *stream);

+int fseek(FILE *stream, long offset, int whence);

+int fprintf(FILE *f, const char *fmt, ...);

+long strtol(const char *nptr, char **endptr, int base);

+char *strchr(const char *s, int c);

+char *strcat(char *s1, const char *s2);

+char *fgets(char *s, int n, FILE *stream);

+FILE *tmpfile(void);

+int feof(FILE *stream);

+int fscanf(FILE *stream, const char *format, ...);

+int ungetc(int c, FILE *stream);

+long ftell(FILE *stream);

+int fputc(int c, FILE *stream);

+int remove(const char *path);

+int ferror(FILE *stream);

+int fputs(const char *s, FILE *stream);

+int fflush(FILE *stream);

+#endif

+#include <stdio.h>

+

+int dprintf(int fd, const char *format, ...) {

+ va_list ap;

+ va_start(ap, format);

+ int rc = vdprintf(fd, format, ap);

+ va_end(ap);

+ return rc;

+}

+#include <stdio.h>

+#include <stdlib.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fclose.html

+// FIXME: Do some actual error checking.

+int fclose(FILE *stream) {

+ free(stream->cookie);

+ free(stream);

+ return 0;

+}

+#include <stdio.h>

+

+int feof(FILE *stream) {

+ return stream->is_eof;

+}

+#include <stdio.h>

+

+int ferror(FILE *stream) {

+ return stream->has_error;

+}

+#include <stdio.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fflush.html

+int fflush(FILE *stream) {

+ // FIXME: Implement

+ return 0;

+}

+#include <assert.h>

+#include <stdio.h>

+

+int fgetc(FILE *stream) {

+ if (stream->has_buffered_char) {

+ stream->has_buffered_char = 0;

+ return stream->buffered_char;

+ }

+ char c;

+ if (1 == fread(&c, 1, 1, stream))

+ return (int)c;

+ // FIXME: Should use feof and ferror

+ if (stream->has_error)

+ return EOF;

+ if (stream->is_eof)

+ return EOF;

+ // How did we get here?

+ assert(0);

+ return EOF;

+}

+#include <stdio.h>

+

+// FIXME: Error handling

+int fgetpos(FILE *restrict stream, fpos_t *restrict pos) {

+ *pos = (fpos_t)stream->offset_in_file;

+ return 0;

+}

+#include <stdio.h>

+

+char *fgets(char *s, int n, FILE *stream) {

+ for (int i = 0; i < n; i++) {

+ char c;

+ fread(&c, 1, 1, stream);

+ if (stream->has_error)

+ return NULL;

+ if (stream->is_eof)

+ return NULL;

+ s[i] = c;

+ if (c == '\n')

+ break;

+ }

+ return s;

+}

+#include <stdio.h>

+#include <errno.h>

+

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fileno.html

+// The fileno() function shall return the integer file descriptor associated

+// with the stream pointed to by stream.

+int fileno(FILE *stream) {

+ if (-1 == stream->fd) {

+ errno = EBADF;

+ return -1;

+ }

+ return stream->fd;

+}

+#include <fcntl.h>

+#include <sys/stat.h>

+#include <stdint.h>

+#include <stdio.h>

+

+// FIXME: All modes not implemented

+// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html

+FILE *fopen(const char *pathname, const char *mode) {

+ uint8_t read = 0;

+ uint8_t write = 0;

+ uint8_t append = 0;

+ // FIXME: Not parsed correctly

+ for (; *mode; mode++) {

+ // r or rb

+ // Open file for reading.

+ // w or wb

+ // Truncate to zero length or create file for writing.

+ // a or ab

+ // Append; open or create file for writing at

+ // end-of-file.

+ switch (*mode) {

+ case 'r':

+ read = 1;

+ break;

+ case 'w':

+ write = 1;

+ break;

+ case 'a':

+ append = 1;

+ break;

+ }

+ }

+ int flag = 0;

+ if (read)

+ flag |= O_READ;

+ if (write)

+ flag |= O_WRITE;

+

+ int fd = open(pathname, flag, 0);

+ if (-1 == fd)

+ return NULL;

+

+ struct stat s;

+ stat(pathname, &s);

+

+ FILE *r = malloc(sizeof(FILE));

+ r->read = read_fd;

+ r->write = write_fd;

+ r->seek = seek_fd;

+ r->has_error = 0;

+ r->is_eof = 0;

+ r->offset_in_file = 0;

+ r->file_size = s.st_size;

+ r->cookie = NULL;

+ r->fd = fd;

+ return r;

+}

+#include <stdio.h>

+

+int fprintf(FILE *f, const char *fmt, ...) {

+ va_list ap;

+ va_start(ap, fmt);

+ int rc = vfprintf(f, fmt, ap);

+ va_end(ap);

+ return rc;

+}

+#include <stdio.h>

+

+int fputc(int c, FILE *stream) {

+ if (fwrite(&c, 1, 1, stream) > 0)

+ return c;

+ return EOF;

+}

+#include <stdio.h>

+

+int fputs(const char *s, FILE *stream) {

+ const char *b = s;

+ for (; *s; s++)

+ if (0 == fwrite(s, 1, 1, stream))

+ return EOF;

+ return s - b;

+}

+#include <stdio.h>

+#include <sys/types.h>

+

+size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) {

+ // FIXME: Check for overflow

+ ssize_t bytes_to_read = nmemb * size;

+ size_t rc = stream->read(stream, ptr, bytes_to_read);

+ // On success, fread() return the number of items read

+ rc /= size;

+ return rc;

+}

+#include <stdio.h>

+#include <assert.h>

+

+int fscanf(FILE *stream, const char *format, ...) {

+ // FIXME

+ assert(0);

+}

+#include <stdio.h>

+#include <assert.h>

+

+int fseek(FILE *stream, long offset, int whence) {

+ return stream->seek(stream, offset, whence);

+ /*

+ switch (whence) {

+ case SEEK_SET:

+ stream->offset_in_file = offset;

+ break;

+ case SEEK_CUR:

+ stream->offset_in_file += offset;

+ break;

+ case SEEK_END:

+ // FIXME

+ assert(0);

+ break;

+ }

+ // FIXME: Error checking

+ return 0;*/

+}

+#include <stdio.h>

+

+// FIXME: Error handling

+int fsetpos(FILE *stream, const fpos_t *pos) {

+ stream->offset_in_file = (long)(*pos);

+ return 0;

+}

+#include <stdio.h>

+

+long ftell(FILE *stream) {

+ return stream->offset_in_file;

+}

+#include <stdio.h>

+#include <sys/types.h>

+

+size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) {

+ // FIXME: Check for overflow

+ ssize_t bytes_to_write = nmemb * size;

+ size_t rc = stream->write(stream, ptr, bytes_to_write);

+ // On success, fwrite() return the number of items

+ // written.

+ rc /= size;

+ return rc;

+}

+#include <stdio.h>

+

+// The getchar() function shall be equivalent to getc(stdin).

+int getchar(void) { return fgetc(stdin); }

+#include <assert.h>

+#include <stddef.h>

+#include <stdio.h>

+#include <stdlib.h>

+/*

+struct __IO_FILE {

+ size_t (*write)(FILE *, const unsigned char *, size_t);

+ size_t (*read)(FILE *, unsigned char *, size_t);

+ int (*seek)(FILE *, long, int);

+ long offset_in_file;

+ int buffered_char;

+ int has_buffered_char;

+ int fd;

+ uint8_t is_eof;

+ uint8_t has_error;

+ uint64_t file_size;

+ void *cookie;

+};

+*/

+

+struct Memstream {

+ size_t buffer_usage;

+ char *buffer;

+};

+

+#define MEMSTREAM_DEF_SIZE 4096

+

+size_t memstream_write(FILE *fp, const unsigned char *buf, size_t n) {

+ struct Memstream *c = fp->cookie;

+ // FIXME: Do a reallocation

+ if (c->buffer_usage + n >= fp->file_size) {

+ n = fp->file_size - c->buffer_usage;

+ }

+

+ memcpy(c->buffer + fp->offset_in_file, buf, n);

+ fp->offset_in_file += n;

+ if (fp->offset_in_file > c->buffer_usage)

+ c->buffer_usage = fp->offset_in_file;

+ return n;

+}

+

+size_t memstream_read(FILE *fp, unsigned char *buf, size_t n) {

+ struct Memstream *c = fp->cookie;

+ size_t length_left = c->buffer_usage - fp->offset_in_file;

+ n = min(length_left, n);

+ memcpy(buf, c->buffer + fp->offset_in_file, n);

+ fp->offset_in_file += n;

+ if (0 == n)

+ fp->is_eof = 1;

+ return n;

+}

+

+int memstream_seek(FILE *stream, long offset, int whence) {

+ switch (whence) {

+ case SEEK_SET:

+ stream->offset_in_file = offset;

+ break;

+ case SEEK_CUR:

+ stream->offset_in_file += offset;

+ break;

+ case SEEK_END:

+ stream->offset_in_file = stream->file_size + offset;

+ break;

+ default:

+ assert(0);

+ break;

+ }

+ // FIXME: Error checking

+ return 0;

+}

+

+FILE *open_memstream(char **bufp, size_t *sizep) {

+ struct Memstream *c = NULL;

+ FILE *fp = malloc(sizeof(FILE));

+ if (!fp)

+ return NULL;

+

+ fp->offset_in_file = 0;

+ fp->buffered_char = 0;

+ fp->has_buffered_char = 0;

+ fp->seek = memstream_seek;

+ fp->fd = -1;

+ fp->is_eof = 0;

+ fp->has_error = 0;

+ fp->file_size = MEMSTREAM_DEF_SIZE;

+

+ fp->write = memstream_write;

+ fp->read = memstream_read;

+

+ c = malloc(sizeof(struct Memstream));

+ if (!c) {

+ goto _exit_memstream_fail;

+ }

+

+ fp->cookie = (void *)c;

+

+ c->buffer = *bufp = malloc(MEMSTREAM_DEF_SIZE);

+ if (!bufp) {

+ goto _exit_memstream_fail;

+ }

+ c->buffer_usage = 0;

+

+ return fp;

+_exit_memstream_fail:

+ free(c);

+ free(fp);

+ return NULL;

+}

+#include <stdio.h>

+

+int printf(const char *format, ...) {

+ va_list ap;

+ va_start(ap, format);

+ int rc = vprintf(format, ap);

+ va_end(ap);

+ return rc;

+}

+#include <stdio.h>

+

+int putc(int c, FILE *stream) { return fputc(c, stream);}

+#include <stdio.h>

+#include <unistd.h>

+

+int putchar(int c) {

+ printf("%c", (char)c);

+ return c;

+}

+#include <stdio.h>

+

+int puts(const char *s) {

+ int rc = printf("%s\n", s);

+ return rc;

+}

+#include <stdio.h>

+#include <errno.h>

+

+extern int errno;

+int remove(const char *path) {

+ // FIXME

+ errno = ENAMETOOLONG;

+ return -1;

+}

+#include <stdio.h>

+#include <assert.h>

+

+int rename(const char *old, const char *new) {

+ (void)old;

+ (void)new;

+ assert(0); // TODO: Implement

+ }

+#include <stdio.h>

+

+int setvbuf(FILE *restrict stream, char *restrict buf, int type, size_t size) {

+ // TODO

+ return 0;

+}

+#include <stddef.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <string.h>

+

+struct sn_cookie {

+ char *s;

+ size_t n;

+};

+

+#define MIN(a, b) ((a) < (b) ? (a) : (b))

+

+size_t sn_write(FILE *f, const unsigned char *s, const size_t l) {

+ struct sn_cookie *c = f->cookie;

+ size_t k = MIN(l, c->n);

+ memcpy(c->s, s, k);

+ c->s += k;

+ c->n -= k;

+ *(c->s) = '\0';

+ // Upon successful completion, the snprintf() function shall return the number

+ // of bytes that would be written to s had n been sufficiently large excluding

+ // the terminating null byte.

+ return l;

+}

+

+int vsnprintf(char *str, size_t size, const char *format, va_list ap) {

+ char dummy[1];

+ struct sn_cookie c = {.s = (size ? str : dummy), .n = (size ? size - 1 : 0)};

+ FILE f = {

+ .write = sn_write,

+ .cookie = &c,

+ };

+ return vfprintf(&f, format, ap);

+}

+

+int snprintf(char *str, size_t size, const char *format, ...) {

+ va_list ap;

+ va_start(ap, format);

+ int rc = vsnprintf(str, size, format, ap);

+ va_end(ap);

+ return rc;

+}

+#include <stddef.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <string.h>

+

+struct s_cookie {

+ char *s;

+};

+

+size_t s_write(FILE *f, const unsigned char *s, size_t l) {

+ struct s_cookie *c = f->cookie;

+ memcpy(c->s, s, l);

+ c->s += l;

+ *(c->s) = '\0';

+ return l;

+}

+

+int vsprintf(char *str, const char *format, va_list ap) {

+ struct s_cookie c = {.s = str};

+ FILE f = {

+ .write = s_write,

+ .cookie = &c,

+ };

+ return vfprintf(&f, format, ap);

+}

+

+int sprintf(char *str, const char *format, ...) {

+ va_list ap;

+ va_start(ap, format);

+ int rc = vsprintf(str, format, ap);

+ va_end(ap);

+ return rc;

+}

+#include <stdio.h>

+#include <unistd.h>

+

+FILE __stderr_FILE = {

+ .write = write_fd,

+ .read = read_fd,

+ .is_eof = 0,

+ .has_error = 0,

+ .cookie = NULL,

+ .fd = 2,

+};

+#include <assert.h>

+#include <stdio.h>

+#include <unistd.h>

+

+size_t write_fd(FILE *f, const unsigned char *s, size_t l) {

+ int rc = pwrite(f->fd, s, l, f->offset_in_file);

+ if (rc == -1) {

+ f->has_error = 1;

+ return 0;

+ }

+ f->offset_in_file += rc;

+ return rc;

+}

+

+size_t read_fd(FILE *f, unsigned char *s, size_t l) {

+ int rc = pread(f->fd, s, l, f->offset_in_file);

+ if (rc == 0)

+ f->is_eof = 1;

+ if (rc == -1) {

+ f->has_error = 1;

+ return 0;

+ }

+ f->offset_in_file += rc;

+ return rc;

+}

+

+int seek_fd(FILE *stream, long offset, int whence) {

+ switch (whence) {

+ case SEEK_SET:

+ stream->offset_in_file = offset;

+ break;

+ case SEEK_CUR:

+ stream->offset_in_file += offset;

+ break;

+ case SEEK_END:

+ stream->offset_in_file = stream->file_size + offset;

+ break;

+ default:

+ assert(0);

+ break;

+ }

+ // FIXME: Error checking

+ return 0;

+}

+

+FILE __stdin_FILE = {

+ .write = write_fd,

+ .read = read_fd,

+ .seek = NULL,

+ .is_eof = 0,

+ .has_error = 0,

+ .cookie = NULL,

+ .fd = 0,

+};

+#include <stdio.h>

+#include <unistd.h>

+

+FILE __stdout_FILE = {

+ .write = write_fd,

+ .read = read_fd,

+ .is_eof = 0,

+ .has_error = 0,

+ .seek = NULL,

+ .cookie = NULL,

+ .fd = 1,

+};

+FILE __stderr_FILE;

+#include <stdio.h>

+#include <assert.h>

+

+FILE *tmpfile(void) {

+ // TODO

+ printf("TODO: Implement tmpfile()\n");

+ assert(0);

+ return NULL;

+}

+#include <assert.h>

+#include <stdio.h>

+

+char *tmpnam(char *s) {

+ assert(!s);

+ s = malloc(100);

+ strcpy(s, "/tmp.XXXXXX");

+ mkstemp(s);

+ return s;

+}

+#include <stdio.h>

+

+int ungetc(int c, FILE *stream) {

+ if (stream->has_buffered_char)

+ return EOF;

+ stream->buffered_char = c;

+ stream->has_buffered_char = 1;

+ return c;

+}

+#include <stdint.h>

+#include <stdio.h>

+#include <string.h>

+#include <unistd.h>

+

+struct vd_cookie {

+ int fd;

+ char *buffer;

+ uint8_t buf_len;

+ uint8_t buf_used;

+ int sent_bytes;

+};

+

+size_t min(size_t a, size_t b) { return (a < b) ? a : b; }

+

+size_t vd_write(FILE *f, const unsigned char *s, size_t l) {

+ struct vd_cookie *c = f->cookie;

+

+ int clear_buffer = 0;

+ size_t b_copy = min(l, c->buf_len - (c->buf_used));

+ for (int i = 0; i < b_copy; i++) {

+ c->buffer[c->buf_used + i] = s[i];

+ if (s[i] == '\n')

+ clear_buffer = 1;

+ }

+ c->buf_used += b_copy;

+

+ if (clear_buffer) {

+ int rc = write(c->fd, c->buffer, c->buf_used);

+ c->buf_used = 0;

+ if (-1 == rc) {

+ return (size_t)-1;

+ }

+ c->sent_bytes += rc;

+ }

+ return l;

+}

+

+int vdprintf(int fd, const char *format, va_list ap) {

+ FILE f = {

+ .write = write_fd,

+ .fd = fd,

+ };

+ return vfprintf(&f, format, ap);

+ // return -1;

+ /*

+char buffer[32];

+struct vd_cookie c = {.fd = fd,

+ .buffer = buffer,

+ .buf_len = 32,