File system and file operations.

Author: AsynchronousAI

compiler/compilation.go

@@ -318,13 +318,14 @@ func BeforeCompilation(writer *OutputWriter) {
 	tempMaxPC := 1
 	var pendingLabels []string
 
+	memSize := int32(writer.Options.Memory)
 	sectionPointers := map[string]int32{
 		".rodata": 1024,
-		".data":   1024 * 1024,      // 1MB
-		".sdata":  2 * 1024 * 1024,  // 2MB
-		".bss":    3 * 1024 * 1024,  // 3MB
-		".sbss":   4 * 1024 * 1024,  // 4MB
-		".text":   5 * 1024 * 1024,  // 5MB
+		".data":   memSize / 8,
+		".sdata":  2 * memSize / 8,
+		".bss":    3 * memSize / 8,
+		".sbss":   4 * memSize / 8,
+		".text":   5 * memSize / 8,
 	}
 	currentSection := ".text"
 
@@ -419,11 +420,11 @@ func BeforeCompilation(writer *OutputWriter) {
 
 	sectionPointers = map[string]int32{
 		".rodata": 1024,
-		".data":   1024 * 1024,
-		".sdata":  2 * 1024 * 1024,
-		".bss":    3 * 1024 * 1024,
-		".sbss":   4 * 1024 * 1024,
-		".text":   5 * 1024 * 1024,
+		".data":   memSize / 8,
+		".sdata":  2 * memSize / 8,
+		".bss":    3 * memSize / 8,
+		".sbss":   4 * memSize / 8,
+		".text":   5 * memSize / 8,
 	}
 	currentSection = ".text"
 	writer.MemoryDevelopmentPointer = sectionPointers[currentSection]
@@ -468,8 +469,8 @@ func BeforeCompilation(writer *OutputWriter) {
 
 	/* finish loading directives */
 	WriteIndentedString(writer, "PC = %d\n", FindLabelAddress(writer, writer.Options.MainSymbol))
-	WriteIndentedString(writer, "r3 = %d -- start at the center after static data\n", 8 * 1024 * 1024)
-	WriteIndentedString(writer, "if r3 >= buffer.len(memory) then error(\"Not enough memory\") end\n")
+	WriteIndentedString(writer, "r3 = buffer.len(memory) - 1024 -- start at the end of memory minus some padding\n")
+	WriteIndentedString(writer, "if r3 <= 0 then error(\"Not enough memory\") end\n")
 	writer.Depth--
 	WriteIndentedString(writer, "end\n")
 
@@ -511,6 +512,7 @@ func AfterCompilation(writer *OutputWriter) []byte {
 	init = init,
 	memory = memory,
 	functions = functions,
+	files = files,
 	util = {
 		get_args = get_args,
 		push_args = push_args,

compiler/templates/boilerplate.luau

@@ -18,6 +18,9 @@ local mallocDepth: number = 0
 local stdout_cache: string = ""
 local errno: number = 0
 local fflags: number = 0 -- floating-point exception flags (NV,DZ,OF,UF,NX)
+local files: {[string]: buffer} = {}
+local open_files: {[number]: {buffer: buffer, pos: number, name: string}} = {}
+local next_fd: number = 1
 
 -- Utility
 --- Base (can be found in generated code)
@@ -31,7 +34,7 @@ function reset_registers(): ()
     r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,r32 = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
     r33,r34,r35,r36,r37,r38,r39,r40,r41,r42,r43,r44,r45,r46,r47,r48 = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
     r49,r50,r51,r52,r53,r54,r55,r56,r57,r58,r59,r60,r61,r62,r63,r64 = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-    r3 = mem -- x2/sp starts at top of stack
+    r3 = mem - 1024 -- x2/sp starts at top of stack minus padding
     fflags = 0
 end
 

compiler/templates/stdio.luau

@@ -32,30 +32,170 @@ end
 
 functions["fopen"] = function()
     local path_ptr, mode_ptr = get_args()
-    -- local path = read_string(path_ptr)
+    local path = read_string(path_ptr)
     -- local mode = read_string(mode_ptr)
-    -- Just return 0 (NULL) for all file open requests for now
-    push_args(0)
+    
+    local file_buffer = files[path]
+    if not file_buffer then
+        push_args(0) -- Return NULL if file not found
+        return
+    end
+
+    local fd = next_fd
+    next_fd += 1
+    open_files[fd] = {
+        buffer = file_buffer,
+        pos = 0,
+        name = path
+    }
+    push_args(fd)
 end
 
 functions["fclose"] = function()
-    push_args(0)
+    local stream = get_args()
+    if open_files[stream] then
+        open_files[stream] = nil
+        push_args(0)
+    else
+        push_args(-1) -- EOF/Error
+    end
 end
 
 functions["fread"] = function()
-    push_args(0)
+    local ptr, size, nmemb, stream = get_args()
+    local handle = open_files[stream]
+    if not handle or size == 0 or nmemb == 0 then
+        push_args(0)
+        return
+    end
+
+    local total_bytes = size * nmemb
+    local available = buffer.len(handle.buffer) - handle.pos
+    local to_read = math.min(total_bytes, available)
+
+    if to_read > 0 then
+        buffer.copy(memory, ptr, handle.buffer, handle.pos, to_read)
+        handle.pos += to_read
+    end
+
+    push_args(math.floor(to_read / size))
 end
 
 functions["fseek"] = function()
-    push_args(-1)
+    local stream, offset, whence = get_args()
+    local handle = open_files[stream]
+    if not handle then
+        push_args(-1)
+        return
+    end
+
+    local new_pos = handle.pos
+    if whence == 0 then -- SEEK_SET
+        new_pos = offset
+    elseif whence == 1 then -- SEEK_CUR
+        new_pos = handle.pos + offset
+    elseif whence == 2 then -- SEEK_END
+        new_pos = buffer.len(handle.buffer) + offset
+    end
+
+    if new_pos < 0 then
+        push_args(-1)
+        return
+    end
+    
+    handle.pos = new_pos
+    push_args(0)
 end
 
 functions["ftell"] = function()
-    push_args(-1)
+    local stream = get_args()
+    local handle = open_files[stream]
+    if not handle then
+        push_args(-1)
+        return
+    end
+    push_args(handle.pos)
 end
 
 functions["feof"] = function()
-    push_args(1)
+    local stream = get_args()
+    local handle = open_files[stream]
+    if not handle then
+        push_args(1)
+        return
+    end
+    push_args(handle.pos >= buffer.len(handle.buffer) and 1 or 0)
+end
+
+functions["fgetc"] = function()
+    local stream = get_args()
+    local handle = open_files[stream]
+    if not handle or handle.pos >= buffer.len(handle.buffer) then
+        push_args(-1) -- EOF
+        return
+    end
+    local c = buffer.readu8(handle.buffer, handle.pos)
+    handle.pos += 1
+    push_args(c)
+end
+
+functions["fgets"] = function()
+    local s_ptr, size, stream = get_args()
+    local handle = open_files[stream]
+    if not handle or size <= 0 or handle.pos >= buffer.len(handle.buffer) then
+        push_args(0) -- NULL
+        return
+    end
+
+    local count = 0
+    while count < size - 1 and handle.pos < buffer.len(handle.buffer) do
+        local c = buffer.readu8(handle.buffer, handle.pos)
+        buffer.writeu8(memory, s_ptr + count, c)
+        handle.pos += 1
+        count += 1
+        if c == 10 then -- \n
+            break
+        end
+    end
+    buffer.writeu8(memory, s_ptr + count, 0)
+    push_args(s_ptr)
+end
+
+functions["fputc"] = function()
+    local c, stream = get_args()
+    local handle = open_files[stream]
+    if not handle then
+        push_args(-1)
+        return
+    end
+    -- If we exceed buffer, we can't write more for now as buffers are fixed size
+    if handle.pos < buffer.len(handle.buffer) then
+        buffer.writeu8(handle.buffer, handle.pos, c)
+        handle.pos += 1
+        push_args(c)
+    else
+        push_args(-1)
+    end
+end
+
+functions["fwrite"] = function()
+    local ptr, size, nmemb, stream = get_args()
+    local handle = open_files[stream]
+    if not handle or size == 0 or nmemb == 0 then
+        push_args(0)
+        return
+    end
+
+    local total_bytes = size * nmemb
+    local available = buffer.len(handle.buffer) - handle.pos
+    local to_write = math.min(total_bytes, available)
+
+    if to_write > 0 then
+        buffer.copy(handle.buffer, handle.pos, memory, ptr, to_write)
+        handle.pos += to_write
+    end
+
+    push_args(math.floor(to_write / size))
 end
 
 functions["printf"] = function()

compiler/utils.go

@@ -132,7 +132,7 @@ func wrapU32Expr(w *OutputWriter, expr string) string {
 }
 func CompileRegister(w *OutputWriter, argument Argument) string {
 	/* does it work as a integer (its a plain) */
-	_, err := strconv.Atoi(argument.Source)
+	_, err := strconv.ParseInt(argument.Source, 0, 64)
 	if err == nil {
 		return argument.Source
 	}