TODO.md

@@ -15,6 +15,7 @@
 - `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,7 +2,6 @@
 
 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);
@@ -66,34 +65,6 @@ 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 *) * fs->opts.maxDirEntries);
+    nn_vfnode **buffer = nn_alloc(alloc, sizeof(nn_vfnode *));
     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,8 +66,6 @@ nn_computer *nn_newComputer(nn_universe *universe, nn_address address, nn_archit
 		c->resources[i].id = NN_NULL_RESOURCE;
 	}
 
-	c->hasBeep = false;
-
     return c;
 }
 
@@ -654,21 +652,3 @@ 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,7 +16,6 @@ typedef struct nn_resource_t {
 
 typedef struct nn_computer {
     char state;
-	nn_bool_t hasBeep;
     nn_bool_t allocatedError;
     char *err;
     void *userdata;
@@ -52,9 +51,6 @@ 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,7 +784,6 @@ int main(int argc, char **argv) {
         .screenCopyPerTick = 8,
         .screenFillPerTick = 16,
         .screenSetsPerTick = 32,
-		.bitbltPerTick = 8,
 
         .heatPerPixelChange = 0.00005,
         .heatPerPixelReset = 0.00001,

src/neonucleus.h

@@ -524,10 +524,6 @@ 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);
@@ -918,9 +914,6 @@ 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,7 +228,6 @@ 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
@@ -438,6 +437,7 @@ 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;
-        nn_dealloc(alloc, ptr, osize);
+        free(ptr);
         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 nn_resize(alloc, ptr, actualOldSize, nsize);
+        return realloc(ptr, nsize);
     }
 }
 
@@ -207,35 +207,18 @@ 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_pushnumber(L, nn_getEnergy(c));
+    lua_pushinteger(L, nn_getEnergy(c));
     return 1;
 }
 
 static int testLuaArch_computer_maxEnergy(lua_State *L) {
     nn_computer *c = testLuaArch_getComputer(L);
-    lua_pushnumber(L, nn_getEnergy(c));
+    lua_pushinteger(L, nn_getEnergy(c));
     return 1;
 }
 

src/universe.c

@@ -10,26 +10,10 @@ 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);