bin2exe.lua

scripts/bin2exe.lua

@@ -0,0 +1,132 @@
+#!/usr/bin/env lua
+
+local usage = [[
+lua bin2exe.lua infile outfile
+
+Converts a raw binary file to PlayStation 1 (PS-X) executable format.
+]]
+
+function file_size(filename)
+    local file = io.open(filename, "rb")
+    if not file then return nil end
+    local size = file:seek("end")
+    file:close()
+    return size
+end
+
+function main(args)
+    if #args ~= 2 then
+        io.stderr:write(usage)
+        os.exit(1)
+    end
+
+    print(string.format("Input file:  %s", args[1]))
+    print(string.format("Output file: %s", args[2]))
+    
+    -- PS1 executables have a maximum size limit of 2MB
+    local max_size = 0x200000
+    print(string.format("\nChecking input file size (max: %d bytes)...", max_size))
+    
+    local infile_size = file_size(args[1])
+    if not infile_size then
+        io.stderr:write("Error: Cannot open input file " .. args[1] .. "\n")
+        os.exit(1)
+    end
+    
+    print(string.format("Input file size: %d bytes", infile_size))
+    
+    if infile_size > max_size then
+        io.stderr:write(string.format("Error: Input file %s longer than %d bytes\n", args[1], max_size))
+        os.exit(1)
+    end
+
+    print("\nOpening files...")
+    local ofile = io.open(args[2], "wb")
+    if not ofile then
+        io.stderr:write("Error: Cannot open output file " .. args[2] .. "\n")
+        os.exit(1)
+    end
+    
+    local ifile = io.open(args[1], "rb")
+    if not ifile then
+        io.stderr:write("Error: Cannot open input file " .. args[1] .. "\n")
+        os.exit(1)
+    end
+
+    print("Writing PS-X executable header...")
+    
+    -- PS1 executables start with "PS-X EXE" magic string
+    ofile:write("PS-X EXE")
+    
+    -- Write entry point address (where the PS1 will jump to start execution)
+    -- 0x80010000 is a standard entry point in PS1 RAM
+    ofile:seek("set", 0x10)
+    ofile:write(string.pack("<I4", 0x80010000))
+    print("  Entry point:   0x80010000")
+    
+    -- Initial GP/R28 register value (Global Pointer for data addressing)
+    -- 0xFFFFFFFF means it will be set by crt0.S startup code
+    ofile:write(string.pack("<I4", 0xFFFFFFFF))
+    
+    -- Destination address in RAM where the executable will be loaded
+    ofile:write(string.pack("<I4", 0x80010000))
+    print("  Load address:  0x80010000")
+    
+    -- Initial stack pointer (SP/R29) and frame pointer (FP/R30)
+    -- 0x801FFF00 points near the top of the 2MB main RAM
+    ofile:seek("set", 0x30)
+    ofile:write(string.pack("<I4", 0x801FFF00))
+    print("  Stack pointer: 0x801FFF00")
+    
+    -- PS1 executables have an 0x800 (2048) byte header
+    -- Zero fill the rest of the header
+    ofile:seek("set", 0x800)
+    print("  Header padding complete (2048 bytes)")
+
+    -- Copy the actual program binary data after the header
+    print("\nCopying program data...")
+    local buffer_size = 0x2000  -- 8KB chunks for efficient copying
+    local bytes_copied = 0
+    
+    for i = 0, math.ceil(infile_size / buffer_size) - 1 do
+        local buffer = ifile:read(buffer_size)
+        if buffer then
+            ofile:write(buffer)
+            bytes_copied = bytes_copied + #buffer
+            -- Show progress every 64KB
+            if bytes_copied % 0x10000 == 0 or bytes_copied == infile_size then
+                print(string.format("  Copied %d/%d bytes (%.1f%%)", 
+                    bytes_copied, infile_size, (bytes_copied / infile_size) * 100))
+            end
+        end
+    end
+
+    -- PS1 executables must be padded to 0x800 (2048) byte boundaries
+    print("\nAligning to 2048-byte boundary...")
+    local exe_size = ofile:seek()
+    if exe_size % 0x800 ~= 0 then
+        local padding = 0x800 - (exe_size % 0x800)
+        exe_size = exe_size + padding
+        ofile:seek("set", exe_size - 1)
+        ofile:write(string.pack("B", 0))
+        print(string.format("  Added %d bytes of padding", padding))
+    else
+        print("  No padding needed")
+    end
+
+    -- Write the size of the executable (excluding the 0x800 byte header)
+    -- This goes at offset 0x1C in the header
+    ofile:seek("set", 0x1C)
+    ofile:write(string.pack("<I4", exe_size - 0x800))
+    print(string.format("\nProgram size field set to: %d bytes", exe_size - 0x800))
+
+    ifile:close()
+    ofile:close()
+    
+    print(string.format("\nSuccess! PS1 executable created: %s", args[2]))
+    print(string.format("Total file size: %d bytes", exe_size))
+end
+
+-- Run main with command line arguments
+main(arg)
+os.exit(0)

scripts/build.ps1

@@ -1,16 +1,26 @@
 $path_root    = split-path -Path $PSScriptRoot -Parent
 $path_build   = join-path $path_root 'build'
 $path_code    = join-path $path_root 'code'
+$path_scripts = join-path $path_root 'scripts'
 
 if ((test-path $path_build) -eq $false) {
 	new-item -itemtype directory -path $path_build
 }
 
 $armips      = 'armips'
+$bin2exe_lua = join-path $path_scripts 'bin2exe.lua'
 
 $path_fillmem = join-path $path_code    'fillmem'
 $src_fillmem  = join-path $path_fillmem 'fillmem.s'
+$bin_fillmem  = join-path $path_build   'fillmem.bin'
+$exe_fillmem  = join-path $path_build   'fillmem.exe'
 
 push-location $path_build
+write-host "Assembling: $src_fillmem`n"
 & $armips $src_fillmem
+
+write-host 'Generating executable..'
+& lua $bin2exe_lua $bin_fillmem $exe_fillmem
+
+write-host 'Done!'
 pop-location