no longer TODO

this needs to be heavily audieted

TODO.md

@@ -15,7 +15,6 @@
 - `data` component (with error correction codes and maybe synthesizing audio)
 - `redstone` component
 - `internet` component
-- `computer.beep(frequency?: number, duration?: number, volume?: number)`, frequency between 20 and 2000 Hz, duration up to 5 seconds, volume from 0 to 1.
 
 # Bugfixes
 

src/components/screen.c

@@ -2,6 +2,7 @@
 
 nn_screen *nn_newScreen(nn_Context *context, int maxWidth, int maxHeight, int maxDepth, int editableColors, int paletteColors) {
     nn_Alloc *alloc = &context->allocator;
+	// TODO: handle OOMs
     nn_screen *screen = nn_alloc(alloc, sizeof(nn_screen));
     screen->ctx = *context;
     screen->buffer = nn_alloc(alloc, sizeof(nn_scrchr_t) * maxWidth * maxHeight);
@@ -65,6 +66,34 @@ void nn_setResolution(nn_screen *screen, int width, int height) {
     screen->height = height;
 }
 
+nn_bool_t nn_unsafeReallocateScreenBuffer(nn_screen *screen, int maxWidth, int maxHeight) {
+	nn_Alloc *alloc = &screen->ctx.allocator;
+
+	nn_scrchr_t *newBuffer = nn_alloc(alloc, sizeof(nn_scrchr_t) * maxWidth * maxHeight);
+	if(newBuffer == NULL) {
+		return false;
+	}
+
+	for(nn_size_t y = 0; y < maxHeight; y++) {
+		if(y == screen->maxHeight) break;
+		for(nn_size_t x = 0; x < maxWidth; x++) {
+			if(x == screen->maxWidth) break;
+
+			nn_size_t srcIdx = x + y * screen->maxWidth;
+			nn_size_t destIdx = x + y * maxWidth;
+
+			newBuffer[destIdx] = screen->buffer[srcIdx];
+		}
+	}
+
+	nn_dealloc(alloc, screen->buffer, sizeof(nn_scrchr_t) * screen->maxWidth * screen->maxHeight);
+
+	screen->buffer = newBuffer;
+	screen->maxWidth = maxWidth;
+	screen->maxHeight = maxHeight;
+	return true;
+}
+
 void nn_getViewport(nn_screen *screen, int *width, int *height) {
     *width = screen->viewportWidth;
     *height = screen->viewportHeight;

src/components/volatileFilesystem.c

@@ -72,7 +72,7 @@ nn_vfnode *nn_vf_allocDirectory(nn_vfilesystem *fs, const char *name) {
     nn_Alloc *alloc = &fs->ctx.allocator;
     nn_vfnode *node = nn_alloc(alloc, sizeof(nn_vfnode));
     if(node == NULL) return NULL;
-    nn_vfnode **buffer = nn_alloc(alloc, sizeof(nn_vfnode *));
+    nn_vfnode **buffer = nn_alloc(alloc, sizeof(nn_vfnode *) * fs->opts.maxDirEntries);
     if(buffer == NULL) {
         nn_dealloc(alloc, node, sizeof(nn_vfnode));
         return NULL;
@@ -111,7 +111,7 @@ nn_size_t nn_vf_spaceUsedByNode(nn_vfnode *node) {
     if(node->isDirectory) {
         nn_size_t sum = 0;
         for(nn_size_t i = 0; i < node->len; i++) {
-            sum = nn_vf_spaceUsedByNode(node->entries[i]);
+            sum += nn_vf_spaceUsedByNode(node->entries[i]);
         }
         return sum;
     } else {

src/computer.c

@@ -66,6 +66,8 @@ nn_computer *nn_newComputer(nn_universe *universe, nn_address address, nn_archit
 		c->resources[i].id = NN_NULL_RESOURCE;
 	}
 
+	c->hasBeep = false;
+
     return c;
 }
 
@@ -652,3 +654,21 @@ const char *nn_resource_nextMethodInfo(nn_computer *computer, nn_size_t id, cons
 nn_deviceInfoList_t *nn_getComputerDeviceInfoList(nn_computer *computer) {
 	return computer->deviceInfo;
 }
+
+void nn_computer_clearBeep(nn_computer *computer) {
+	computer->hasBeep = false;
+}
+
+void nn_computer_setBeep(nn_computer *computer, double frequency, double duration, double volume) {
+	computer->hasBeep = true;
+	computer->beepFrequency = frequency;
+	computer->beepDuration = duration;
+	computer->beepVolume = volume;
+}
+
+nn_bool_t nn_computer_getBeep(nn_computer *computer, double *frequency, double *duration, double *volume) {
+	if(frequency != NULL) *frequency = computer->beepFrequency;
+	if(duration != NULL) *duration = computer->beepDuration;
+	if(volume != NULL) *volume = computer->beepVolume;
+	return computer->hasBeep;
+}

src/computer.h

@@ -16,6 +16,7 @@ typedef struct nn_resource_t {
 
 typedef struct nn_computer {
     char state;
+	nn_bool_t hasBeep;
     nn_bool_t allocatedError;
     char *err;
     void *userdata;
@@ -51,6 +52,9 @@ typedef struct nn_computer {
 	nn_size_t rid;
 	nn_resource_t resources[NN_MAX_CONCURRENT_RESOURCES];
 	nn_deviceInfoList_t *deviceInfo;
+	double beepFrequency;
+	double beepDuration;
+	double beepVolume;
 } nn_computer;
 
 #endif

src/emulator.c

@@ -784,6 +784,7 @@ int main(int argc, char **argv) {
         .screenCopyPerTick = 8,
         .screenFillPerTick = 16,
         .screenSetsPerTick = 32,
+		.bitbltPerTick = 8,
 
         .heatPerPixelChange = 0.00005,
         .heatPerPixelReset = 0.00001,

src/neonucleus.h

@@ -524,6 +524,10 @@ nn_guard *nn_getComputerLock(nn_computer *computer);
 int nn_getState(nn_computer *computer);
 void nn_setState(nn_computer *computer, int state);
 
+void nn_computer_clearBeep(nn_computer *computer);
+void nn_computer_setBeep(nn_computer *computer, double frequency, double duration, double volume);
+nn_bool_t nn_computer_getBeep(nn_computer *computer, double *frequency, double *duration, double *volume);
+
 void nn_setEnergyInfo(nn_computer *computer, double energy, double capacity);
 double nn_getEnergy(nn_computer *computer);
 double nn_getMaxEnergy(nn_computer *computer);
@@ -914,6 +918,9 @@ void nn_unlockScreen(nn_screen *screen);
 void nn_getResolution(nn_screen *screen, int *width, int *height);
 void nn_maxResolution(nn_screen *screen, int *width, int *height);
 void nn_setResolution(nn_screen *screen, int width, int height);
+// changes the maximum resolution
+// DOES NOT USE THE LOCK AND THUS MAY CAUSE RACE CONDITIONS AND SEGFAULTS!!!!!
+nn_bool_t nn_unsafeReallocateScreenBuffer(nn_screen *screen, int maxWidth, int maxHeight);
 
 void nn_getViewport(nn_screen *screen, int *width, int *height);
 void nn_setViewport(nn_screen *screen, int width, int height);

src/sandbox.lua

@@ -228,6 +228,7 @@ local libcomputer = {
         local deadline = computer.uptime() + (type(timeout) == "number" and timeout or math.huge)
 
         repeat
+			print("waiting for signal", computer.uptime())
             yield() -- give executor a chance to give us stuff
             local s = table.pack(computer.popSignal())
             if s.n > 0 then
@@ -437,7 +438,6 @@ local lastGC = computer.uptime()
 while true do
     timeout = nextDeadline()
     bubbleYield = false
-    collectgarbage()
 
     if computer.uptime() - lastGC >= gcInterval then
         collectgarbage("collect")

src/testLuaArch.c

@@ -69,7 +69,7 @@ void *testLuaArch_alloc(testLuaArch *arch, void *ptr, size_t osize, size_t nsize
     nn_Alloc *alloc = nn_getAllocator(nn_getUniverse(arch->computer));
     if(nsize == 0) {
         arch->memoryUsed -= osize;
-        free(ptr);
+        nn_dealloc(alloc, ptr, osize);
         return NULL;
     } else {
         size_t actualOldSize = osize;
@@ -79,7 +79,7 @@ void *testLuaArch_alloc(testLuaArch *arch, void *ptr, size_t osize, size_t nsize
         }
         arch->memoryUsed -= actualOldSize;
         arch->memoryUsed += nsize;
-        return realloc(ptr, nsize);
+        return nn_resize(alloc, ptr, actualOldSize, nsize);
     }
 }
 
@@ -207,18 +207,35 @@ static int testLuaArch_computer_uptime(lua_State *L) {
 
 // TODO: beep
 static int testLuaArch_computer_beep(lua_State *L) {
+    nn_computer *c = testLuaArch_getComputer(L);
+	// defaults
+	double frequency = 200;
+	double duration = 0.25;
+	double volume = 1;
+
+	if(lua_type(L, 1) == LUA_TNUMBER) {
+		frequency = lua_tonumber(L, 1);
+	}
+	if(lua_type(L, 2) == LUA_TNUMBER) {
+		duration = lua_tonumber(L, 2);
+	}
+	if(lua_type(L, 3) == LUA_TNUMBER) {
+		volume = lua_tonumber(L, 3);
+	}
+
+	nn_computer_setBeep(c, frequency, duration, volume);
     return 0;
 }
 
 static int testLuaArch_computer_energy(lua_State *L) {
     nn_computer *c = testLuaArch_getComputer(L);
-    lua_pushinteger(L, nn_getEnergy(c));
+    lua_pushnumber(L, nn_getEnergy(c));
     return 1;
 }
 
 static int testLuaArch_computer_maxEnergy(lua_State *L) {
     nn_computer *c = testLuaArch_getComputer(L);
-    lua_pushinteger(L, nn_getEnergy(c));
+    lua_pushnumber(L, nn_getEnergy(c));
     return 1;
 }
 

src/universe.c

@@ -10,10 +10,26 @@ nn_universe *nn_newUniverse(nn_Context ctx) {
     return u;
 }
 
+nn_Context *nn_getContext(nn_universe *universe) {
+	return &universe->ctx;
+}
+
 nn_Alloc *nn_getAllocator(nn_universe *universe) {
     return &universe->ctx.allocator;
 }
 
+nn_Clock *nn_getClock(nn_universe *universe) {
+	return &universe->ctx.clock;
+}
+
+nn_LockManager *nn_getLockManager(nn_universe *universe) {
+	return &universe->ctx.lockManager;
+}
+
+nn_Rng *nn_getRng(nn_universe *universe) {
+	return &universe->ctx.rng;
+}
+
 void nn_unsafeDeleteUniverse(nn_universe *universe) {
     for(nn_size_t i = 0; i < universe->udataLen; i++) {
         nn_deallocStr(&universe->ctx.allocator, universe->udata[i].name);