NeoFlock/neonucleus
9
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

experimental baremetal

Browse Source 
we no longer depend on libc
This commit is contained in:
IonutParau
2025-07-09 19:17:57 +02:00
parent 779d5a0c19
commit 51b3602088
19 changed files with 332 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/components/drive.c
View File

@@ -14,7 +14,7 @@ nn_driveControl nn_drive_getControl(nn_component *component, nn_drive *drive) {
void nn_drive_getLabel(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
char buf[NN_LABEL_SIZE];
size_t l = NN_LABEL_SIZE;
nn_size_t l = NN_LABEL_SIZE;
drive->getLabel(component, drive->userdata, buf, &l);
if(l == 0) {
nn_return(computer, nn_values_nil());
@@ -23,7 +23,7 @@ void nn_drive_getLabel(nn_drive *drive, void *_, nn_component *component, nn_com
}
}
void nn_drive_setLabel(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
size_t l = 0;
nn_size_t l = 0;
nn_value label = nn_getArgument(computer, 0);
const char *buf = nn_toString(label, &l);
if(buf == NULL) {
@@ -34,21 +34,21 @@ void nn_drive_setLabel(nn_drive *drive, void *_, nn_component *component, nn_com
nn_return_string(computer, buf, l);
}
void nn_drive_getSectorSize(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_return(computer, nn_values_integer(sector_size));
}
void nn_drive_getPlatterCount(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
size_t platter_count = drive->getPlatterCount(component, drive->userdata);
nn_size_t platter_count = drive->getPlatterCount(component, drive->userdata);
nn_return(computer, nn_values_integer(platter_count));
}
void nn_drive_getCapacity(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
size_t capacity = drive->getCapacity(component, drive->userdata);
nn_size_t capacity = drive->getCapacity(component, drive->userdata);
nn_return(computer, nn_values_integer(capacity));
}
void nn_drive_readSector(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
nn_value sectorValue = nn_getArgument(computer, 0);
int sector = nn_toInt(sectorValue);
size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_size_t sector_size = drive->getSectorSize(component, drive->userdata);
// we leave the +1 intentionally to compare the end of the real sector
if (sector < 1 || (sector * sector_size > drive->getCapacity(component, drive->userdata))) {
nn_setCError(computer, "bad argument #1 (sector out of range)");
@@ -61,10 +61,10 @@ void nn_drive_readSector(nn_drive *drive, void *_, nn_component *component, nn_c
void nn_drive_writeSector(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
nn_value sectorValue = nn_getArgument(computer, 0);
int sector = nn_toInt(sectorValue);
size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_value bufValue = nn_getArgument(computer, 1);
size_t buf_size = 0;
nn_size_t buf_size = 0;
const char *buf = nn_toString(bufValue, &buf_size);
if (buf_size != sector_size) {
nn_setCError(computer, "bad argument #2 (expected buffer of length `sectorSize`)");
@@ -79,10 +79,10 @@ void nn_drive_writeSector(nn_drive *drive, void *_, nn_component *component, nn_
}
void nn_drive_readByte(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
nn_value offsetValue = nn_getArgument(computer, 0);
size_t disk_offset = nn_toInt(offsetValue) - 1;
size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_size_t disk_offset = nn_toInt(offsetValue) - 1;
nn_size_t sector_size = drive->getSectorSize(component, drive->userdata);
int sector = (disk_offset / sector_size) + 1;
size_t sector_offset = disk_offset % sector_size;
nn_size_t sector_offset = disk_offset % sector_size;
if (disk_offset >= drive->getCapacity(component, drive->userdata)) {
nn_setCError(computer, "bad argument #1 (index out of range)");
@@ -96,11 +96,11 @@ void nn_drive_readByte(nn_drive *drive, void *_, nn_component *component, nn_com
void nn_drive_writeByte(nn_drive *drive, void *_, nn_component *component, nn_computer *computer) {
nn_value offsetValue = nn_getArgument(computer, 0);
nn_value writeValue = nn_getArgument(computer, 1);
size_t disk_offset = nn_toInt(offsetValue) - 1;
intptr_t write = nn_toInt(writeValue);
size_t sector_size = drive->getSectorSize(component, drive->userdata);
nn_size_t disk_offset = nn_toInt(offsetValue) - 1;
nn_intptr_t write = nn_toInt(writeValue);
nn_size_t sector_size = drive->getSectorSize(component, drive->userdata);
int sector = (disk_offset / sector_size) + 1;
size_t sector_offset = disk_offset % sector_size;
nn_size_t sector_offset = disk_offset % sector_size;
if (write < -128 || write > 255) {
nn_setCError(computer, "bad argument #2 (byte out of range)");

22
src/components/eeprom.c
View File

@@ -4,7 +4,7 @@ nn_eepromControl nn_eeprom_getControl(nn_component *component, nn_eeprom *eeprom
return eeprom->control(component, eeprom->userdata);
}
static void nn_eeprom_readCost(nn_component *component, size_t bytesRead) {
static void nn_eeprom_readCost(nn_component *component, nn_size_t bytesRead) {
nn_eepromControl control = nn_eeprom_getControl(component, nn_getComponentUserdata(component));
nn_computer *computer = nn_getComputerOfComponent(component);
@@ -13,7 +13,7 @@ static void nn_eeprom_readCost(nn_component *component, size_t bytesRead) {
nn_simulateBufferedIndirect(component, bytesRead, control.bytesReadPerTick);
}
static void nn_eeprom_writeCost(nn_component *component, size_t bytesWritten) {
static void nn_eeprom_writeCost(nn_component *component, nn_size_t bytesWritten) {
nn_eepromControl control = nn_eeprom_getControl(component, nn_getComponentUserdata(component));
nn_computer *computer = nn_getComputerOfComponent(component);
@@ -40,7 +40,7 @@ void nn_eeprom_getDataSize(nn_eeprom *eeprom, void *_, nn_component *component,
void nn_eeprom_getLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
char buf[NN_LABEL_SIZE];
size_t l = NN_LABEL_SIZE;
nn_size_t l = NN_LABEL_SIZE;
eeprom->getLabel(component, eeprom->userdata, buf, &l);
if(l == 0) {
nn_return(computer, nn_values_nil());
@@ -53,7 +53,7 @@ void nn_eeprom_getLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_
}
void nn_eeprom_setLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
size_t l = 0;
nn_size_t l = 0;
nn_value label = nn_getArgument(computer, 0);
const char *buf = nn_toString(label, &l);
if(buf == NULL) {
@@ -68,14 +68,14 @@ void nn_eeprom_setLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_
}
void nn_eeprom_get(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
size_t cap = eeprom->getSize(component, eeprom->userdata);
nn_size_t cap = eeprom->getSize(component, eeprom->userdata);
nn_Alloc *alloc = nn_getAllocator(nn_getUniverse(computer));
char *buf = nn_alloc(alloc, cap);
if(buf == NULL) {
nn_setCError(computer, "out of memory");
return;
}
size_t len = eeprom->get(component, eeprom->userdata, buf);
nn_size_t len = eeprom->get(component, eeprom->userdata, buf);
nn_return_string(computer, buf, len);
nn_dealloc(alloc, buf, cap);
@@ -84,7 +84,7 @@ void nn_eeprom_get(nn_eeprom *eeprom, void *_, nn_component *component, nn_compu
void nn_eeprom_set(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
nn_value data = nn_getArgument(computer, 0);
size_t len;
nn_size_t len;
const char *buf = nn_toString(data, &len);
if(len > eeprom->getSize(component, eeprom->userdata)) {
nn_setCError(computer, "out of space");
@@ -105,7 +105,7 @@ void nn_eeprom_set(nn_eeprom *eeprom, void *_, nn_component *component, nn_compu
}
void nn_eeprom_getData(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
size_t cap = eeprom->getDataSize(component, eeprom->userdata);
nn_size_t cap = eeprom->getDataSize(component, eeprom->userdata);
nn_Alloc *alloc = nn_getAllocator(nn_getUniverse(computer));
char *buf = nn_alloc(alloc, cap);
if(buf == NULL) {
@@ -125,7 +125,7 @@ void nn_eeprom_getData(nn_eeprom *eeprom, void *_, nn_component *component, nn_c
void nn_eeprom_setData(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
nn_value data = nn_getArgument(computer, 0);
size_t len = 0;
nn_size_t len = 0;
const char *buf = nn_toString(data, &len);
if(buf == NULL) {
if(data.tag == NN_VALUE_NIL) {
@@ -154,8 +154,8 @@ void nn_eeprom_makeReadonly(nn_eeprom *eeprom, void *_, nn_component *component,
}
void nn_eeprom_getChecksum(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
size_t dataCap = eeprom->getDataSize(component, eeprom->userdata);
size_t codeCap = eeprom->getSize(component, eeprom->userdata);
nn_size_t dataCap = eeprom->getDataSize(component, eeprom->userdata);
nn_size_t codeCap = eeprom->getSize(component, eeprom->userdata);
nn_Alloc *alloc = nn_getAllocator(nn_getUniverse(computer));
char *buf = nn_alloc(alloc, dataCap + codeCap);
if(buf == NULL) {

48
src/components/filesystem.c
View File

@@ -12,7 +12,7 @@ nn_bool_t nn_fs_illegalPath(const char *path) {
// absolute disaster
const char *illegal = "\"\\:*?<>|";
for(size_t i = 0; illegal[i] != '\0'; i++) {
for(nn_size_t i = 0; illegal[i] != '\0'; i++) {
if(nn_strchr(path, illegal[i]) != NULL) return true;
}
return false;
@@ -22,28 +22,28 @@ nn_filesystemControl nn_fs_getControl(nn_component *component, nn_filesystem *fs
return fs->control(component, fs->userdata);
}
size_t nn_fs_countChunks(nn_filesystem *fs, size_t bytes, nn_component *component) {
nn_size_t nn_fs_countChunks(nn_filesystem *fs, nn_size_t bytes, nn_component *component) {
nn_filesystemControl control = nn_fs_getControl(component, fs);
size_t chunks = bytes / control.pretendChunkSize;
nn_size_t chunks = bytes / control.pretendChunkSize;
if(bytes % control.pretendChunkSize != 0) chunks++;
return chunks;
}
void nn_fs_readCost(nn_filesystem *fs, size_t count, nn_component *component, nn_computer *computer) {
void nn_fs_readCost(nn_filesystem *fs, nn_size_t count, nn_component *component, nn_computer *computer) {
nn_filesystemControl control = nn_fs_getControl(component, fs);
nn_removeEnergy(computer, control.readEnergyCost * count);
nn_callCost(computer, control.readCostPerChunk * count);
}
void nn_fs_writeCost(nn_filesystem *fs, size_t count, nn_component *component, nn_computer *computer) {
void nn_fs_writeCost(nn_filesystem *fs, nn_size_t count, nn_component *component, nn_computer *computer) {
nn_filesystemControl control = nn_fs_getControl(component, fs);
nn_removeEnergy(computer, control.writeEnergyCost * count);
nn_addHeat(computer, control.writeHeatPerChunk * count);
nn_callCost(computer, control.writeCostPerChunk * count);
}
void nn_fs_seekCost(nn_filesystem *fs, size_t count, nn_component *component, nn_computer *computer) {
void nn_fs_seekCost(nn_filesystem *fs, nn_size_t count, nn_component *component, nn_computer *computer) {
nn_filesystemControl control = nn_fs_getControl(component, fs);
if(control.pretendRPM == 0) return; // disabled, likely SSD
double rps = (double)control.pretendRPM / 60;
@@ -56,7 +56,7 @@ void nn_fs_seekCost(nn_filesystem *fs, size_t count, nn_component *component, nn
void nn_fs_getLabel(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
char buf[NN_LABEL_SIZE];
size_t l = NN_LABEL_SIZE;
nn_size_t l = NN_LABEL_SIZE;
fs->getLabel(component, fs->userdata, buf, &l);
if(l == 0) {
nn_return(computer, nn_values_nil());
@@ -71,7 +71,7 @@ void nn_fs_getLabel(nn_filesystem *fs, void *_, nn_component *component, nn_comp
}
void nn_fs_setLabel(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
size_t l = 0;
nn_size_t l = 0;
nn_value label = nn_getArgument(computer, 0);
const char *buf = nn_toString(label, &l);
if(buf == NULL) {
@@ -85,14 +85,14 @@ void nn_fs_setLabel(nn_filesystem *fs, void *_, nn_component *component, nn_comp
}
void nn_fs_spaceUsed(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
size_t space = fs->spaceUsed(component, fs->userdata);
nn_size_t space = fs->spaceUsed(component, fs->userdata);
nn_return(computer, nn_values_integer(space));
nn_fs_readCost(fs, 1, component, computer);
}
void nn_fs_spaceTotal(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
size_t space = fs->spaceUsed(component, fs->userdata);
nn_size_t space = fs->spaceUsed(component, fs->userdata);
nn_return(computer, nn_values_integer(space));
nn_fs_readCost(fs, 1, component, computer);
@@ -116,7 +116,7 @@ void nn_fs_size(nn_filesystem *fs, void *_, nn_component *component, nn_computer
return;
}
size_t byteSize = fs->size(component, fs->userdata, path);
nn_size_t byteSize = fs->size(component, fs->userdata, path);
nn_return(computer, nn_values_integer(byteSize));
@@ -154,7 +154,7 @@ void nn_fs_lastModified(nn_filesystem *fs, void *_, nn_component *component, nn_
return;
}
size_t t = fs->lastModified(component, fs->userdata, path);
nn_size_t t = fs->lastModified(component, fs->userdata, path);
// OpenOS does BULLSHIT with this thing, dividing it by 1000 and expecting it to be
// fucking usable as a date, meaning it needs to be an int.
@@ -189,7 +189,7 @@ void nn_fs_rename(nn_filesystem *fs, void *_, nn_component *component, nn_comput
return;
}
size_t movedCount = fs->rename(component, fs->userdata, from, to);
nn_size_t movedCount = fs->rename(component, fs->userdata, from, to);
nn_return(computer, nn_values_boolean(movedCount > 0));
// Considered 2 safety checks + 1 read per file + 1 write per file
@@ -263,13 +263,13 @@ void nn_fs_list(nn_filesystem *fs, void *_, nn_component *component, nn_computer
nn_Alloc *alloc = nn_getAllocator(nn_getUniverse(computer));
size_t fileCount = 0;
nn_size_t fileCount = 0;
char **files = fs->list(alloc, component, fs->userdata, path, &fileCount);
if(files != NULL) {
// operation succeeded
nn_value arr = nn_values_array(alloc, fileCount);
for(size_t i = 0; i < fileCount; i++) {
for(nn_size_t i = 0; i < fileCount; i++) {
nn_values_set(arr, i, nn_values_string(alloc, files[i], nn_strlen(files[i])));
nn_deallocStr(alloc, files[i]);
}
@@ -298,7 +298,7 @@ void nn_fs_open(nn_filesystem *fs, void *_, nn_component *component, nn_computer
mode = "r";
}
size_t fd = fs->open(component, fs->userdata, path, mode);
nn_size_t fd = fs->open(component, fs->userdata, path, mode);
nn_return(computer, nn_values_integer(fd));
// 1 safety check
@@ -307,7 +307,7 @@ void nn_fs_open(nn_filesystem *fs, void *_, nn_component *component, nn_computer
void nn_fs_close(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
nn_value fdValue = nn_getArgument(computer, 0);
size_t fd = nn_toInt(fdValue);
nn_size_t fd = nn_toInt(fdValue);
nn_bool_t closed = fs->close(component, fs->userdata, fd);
nn_return(computer, nn_values_boolean(closed));
@@ -318,12 +318,12 @@ void nn_fs_close(nn_filesystem *fs, void *_, nn_component *component, nn_compute
void nn_fs_write(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
nn_value fdValue = nn_getArgument(computer, 0);
size_t fd = nn_toInt(fdValue);
nn_size_t fd = nn_toInt(fdValue);
// size_t spaceRemaining = fs->spaceTotal(component, fs->userdata) - fs->spaceUsed(component, fs->userdata);
nn_value bufferValue = nn_getArgument(computer, 1);
size_t len = 0;
nn_size_t len = 0;
const char *buf = nn_toString(bufferValue, &len);
if(buf == NULL) {
nn_setCError(computer, "bad buffer (string expected)");
@@ -344,9 +344,9 @@ void nn_fs_read(nn_filesystem *fs, void *_, nn_component *component, nn_computer
nn_value lenValue = nn_getArgument(computer, 1);
double len = nn_toNumber(lenValue);
size_t capacity = fs->spaceTotal(component, fs->userdata);
nn_size_t capacity = fs->spaceTotal(component, fs->userdata);
if(len > capacity) len = capacity;
size_t byteLen = len;
nn_size_t byteLen = len;
nn_Alloc *alloc = nn_getAllocator(nn_getUniverse(computer));
char *buf = nn_alloc(alloc, byteLen);
@@ -355,7 +355,7 @@ void nn_fs_read(nn_filesystem *fs, void *_, nn_component *component, nn_computer
return;
}
size_t readLen = fs->read(component, fs->userdata, fd, buf, byteLen);
nn_size_t readLen = fs->read(component, fs->userdata, fd, buf, byteLen);
if(readLen > 0) {
// Nothing read means EoF.
nn_return_string(computer, buf, readLen);
@@ -375,7 +375,7 @@ nn_bool_t nn_fs_validWhence(const char *s) {
}
void nn_fs_seek(nn_filesystem *fs, void *_, nn_component *component, nn_computer *computer) {
size_t fd = nn_toInt(nn_getArgument(computer, 0));
nn_size_t fd = nn_toInt(nn_getArgument(computer, 0));
const char *whence = nn_toCString(nn_getArgument(computer, 1));
@@ -394,7 +394,7 @@ void nn_fs_seek(nn_filesystem *fs, void *_, nn_component *component, nn_computer
// size_t capacity = fs->spaceTotal(component, fs->userdata);
int moved = 0;
size_t pos = fs->seek(component, fs->userdata, fd, whence, off, &moved);
nn_size_t pos = fs->seek(component, fs->userdata, fd, whence, off, &moved);
if(moved < 0) moved = -moved;
// do not ask where it comes from, balance is hard

8
src/components/gpu.c
View File

@@ -99,12 +99,12 @@ void nni_gpu_bind(nni_gpu *gpu, void *_, nn_component *component, nn_computer *c
if(reset) {
for(size_t i = 0; i < screen->width; i++) {
for(size_t j = 0; j < screen->height; j++) {
for(nn_size_t i = 0; i < screen->width; i++) {
for(nn_size_t j = 0; j < screen->height; j++) {
nn_setPixel(screen, i, j, nni_gpu_makePixel(gpu, " "));
}
}
size_t area = screen->width * screen->height;
nn_size_t area = screen->width * screen->height;
nn_addHeat(computer, gpu->ctrl.heatPerPixelReset * area);
nn_simulateBufferedIndirect(component, 1, gpu->ctrl.screenFillPerTick);
nn_removeEnergy(computer, gpu->ctrl.energyPerPixelReset * area);
@@ -159,7 +159,7 @@ void nni_gpu_get(nni_gpu *gpu, void *_, nn_component *component, nn_computer *co
int y = nn_toInt(nn_getArgument(computer, 1)) - 1;
nn_scrchr_t pxl = nn_getPixel(gpu->currentScreen, x, y);
size_t l;
nn_size_t l;
char chr[NN_MAXIMUM_UNICODE_BUFFER];
nn_unicode_codepointToChar(chr, pxl.codepoint, &l);

14
src/components/screen.c
View File

@@ -93,8 +93,8 @@ void nn_addKeyboard(nn_screen *screen, nn_address address) {
}
void nn_removeKeyboard(nn_screen *screen, nn_address address) {
size_t j = 0;
for(size_t i = 0; i < screen->keyboardCount; i++) {
nn_size_t j = 0;
for(nn_size_t i = 0; i < screen->keyboardCount; i++) {
if(nn_strcmp(screen->keyboards[i], address) == 0) {
nn_deallocStr(&screen->ctx.allocator, screen->keyboards[i]);
} else {
@@ -105,12 +105,12 @@ void nn_removeKeyboard(nn_screen *screen, nn_address address) {
screen->keyboardCount = j;
}
nn_address nn_getKeyboard(nn_screen *screen, size_t idx) {
nn_address nn_getKeyboard(nn_screen *screen, nn_size_t idx) {
if(idx >= screen->keyboardCount) return NULL;
return screen->keyboards[idx];
}
size_t nn_getKeyboardCount(nn_screen *screen) {
nn_size_t nn_getKeyboardCount(nn_screen *screen) {
return screen->keyboardCount;
}
@@ -213,9 +213,9 @@ void nn_screenComp_getKeyboards(nn_screen *screen, void *_, nn_component *compon
nn_lockScreen(screen);
nn_value arr = nn_values_array(&screen->ctx.allocator, nn_getKeyboardCount(screen));
size_t len = arr.array->len;
for(size_t i = 0; i < len; i++) {
size_t addrlen = nn_strlen(nn_getKeyboard(screen, i));
nn_size_t len = arr.array->len;
for(nn_size_t i = 0; i < len; i++) {
nn_size_t addrlen = nn_strlen(nn_getKeyboard(screen, i));
nn_value addr = nn_values_string(&screen->ctx.allocator, nn_getKeyboard(screen, i), addrlen);
nn_values_set(arr, i, addr);
}

2
src/components/screen.h
View File

@@ -26,7 +26,7 @@ typedef struct nn_screen {
nn_bool_t isPrecise;
nn_bool_t isDirty;
nn_address keyboards[NN_MAX_SCREEN_KEYBOARDS];
size_t keyboardCount;
nn_size_t keyboardCount;
} nn_screen;
#endif