From 6dc841f956553396d930ea62ddc92e9e70401c28 Mon Sep 17 00:00:00 2001 From: Alvin Date: Thu, 8 Oct 2026 23:36:34 +0200 Subject: [PATCH] e --- BOB64_MIGRATION.md | 395 ++++ C_IMPLEMENTATION.md | 52 + C_OS.md | 93 +- Makefile | 27 +- README.md | 4 + apps/README.md | 111 + apps/bob64_demo.c | 4 + apps/bob64_display.c | 28 + apps/bob64_gui.c | 521 +++++ apps/bob64_smoke.c | 33 + apps/cat.c | 14 + apps/echo.c | 15 + apps/graphics_demo.c | 31 + apps/gui_demo.c | 462 +++++ apps/launcher.c | 51 + apps/ls.c | 29 + apps/notes.c | 103 + apps/sysinfo.c | 50 + bob-files.b32 | Bin 17264 -> 33648 bytes bob.exe | Bin 79583 -> 93959 bytes bob32.exe | Bin 79583 -> 93959 bytes bob64/ABI.md | 124 ++ bob64/README.md | 234 +++ bob64/abi.h | 79 + bob64/app.h | 192 ++ bob64/app_entry.S | 15 + bob64/boot.c | 213 ++ bob64/bootstrap.c | 47 + bob64/bootstrap.h | 23 + bob64/compiler.c | 2255 +++++++++++++++++++++ bob64/compiler.h | 15 + bob64/console.c | 140 ++ bob64/console.h | 16 + bob64/cpu.c | 58 + bob64/cpu.h | 20 + bob64/descriptors.c | 71 + bob64/descriptors.h | 59 + bob64/editor.h | 104 + bob64/efi.h | 200 ++ bob64/embedded_app.S | 28 + bob64/event.h | 33 + bob64/exec.c | 66 + bob64/exec.h | 29 + bob64/filesystem.c | 169 ++ bob64/filesystem.h | 40 + bob64/font.h | 31 + bob64/gfx.h | 82 + bob64/handoff.S | 48 + bob64/heap.c | 128 ++ bob64/heap.h | 34 + bob64/interrupts.S | 420 ++++ bob64/interrupts.c | 259 +++ bob64/interrupts.h | 45 + bob64/kernel.c | 788 ++++++++ bob64/kernel.h | 37 + bob64/keyboard.c | 150 ++ bob64/keyboard.h | 24 + bob64/libc.c | 40 + bob64/libc.h | 13 + bob64/memory.c | 116 ++ bob64/memory.h | 33 + bob64/mouse.c | 171 ++ bob64/mouse.h | 23 + bob64/paging.c | 272 +++ bob64/paging.h | 51 + bob64/process.c | 188 ++ bob64/process.h | 63 + bob64/runtime.h | 14 + bob64/shell.c | 286 +++ bob64/shell.h | 40 + bob64/snapshot.c | 147 ++ bob64/snapshot.h | 15 + bob64/syscall.c | 545 +++++ bob64/syscall.h | 73 + bob64/types.h | 28 + bob64/window.h | 270 +++ bob64/window_server.c | 176 ++ bob64/window_server.h | 43 + build-tool.exe | Bin 42852 -> 47216 bytes kernel.basm | 4015 ++++++++++++++++++++----------------- kernel/API.md | 87 +- kernel/bob.h | 2 + kernel/bob_event.h | 37 + kernel/bob_event_queue.h | 36 + kernel/bob_font.h | 59 + kernel/bob_fs.h | 88 + kernel/bob_gfx.h | 89 + kernel/bob_gui.h | 352 ++++ kernel/bob_memory.h | 18 + kernel/bob_native.h | 15 + kernel/bob_process.h | 14 + kernel/bob_system.h | 21 + kernel/bob_time.h | 18 + kernel/bob_wm.h | 193 ++ kernel/files.c | 27 +- kernel/input.c | 26 +- kernel/kernel.c | 3 + kernel/runtime.h | 5 +- kernel/shell.c | 9 +- main.c | 496 ++++- storage.c | 94 +- tests/AUDIT.md | 66 + tests/test_bob64.c | 2676 ++++++++++++++++++++++++ tests/test_cpu.c | 82 +- tests/test_os.c | 307 ++- tools/bob64cc.c | 193 ++ tools/bobcc.c | 3 +- tools/build.c | 58 +- tools/test_bob64_qemu.ps1 | 104 + 109 files changed, 18192 insertions(+), 1907 deletions(-) create mode 100644 BOB64_MIGRATION.md create mode 100644 apps/README.md create mode 100644 apps/bob64_demo.c create mode 100644 apps/bob64_display.c create mode 100644 apps/bob64_gui.c create mode 100644 apps/bob64_smoke.c create mode 100644 apps/cat.c create mode 100644 apps/echo.c create mode 100644 apps/graphics_demo.c create mode 100644 apps/gui_demo.c create mode 100644 apps/launcher.c create mode 100644 apps/ls.c create mode 100644 apps/notes.c create mode 100644 apps/sysinfo.c create mode 100644 bob64/ABI.md create mode 100644 bob64/README.md create mode 100644 bob64/abi.h create mode 100644 bob64/app.h create mode 100644 bob64/app_entry.S create mode 100644 bob64/boot.c create mode 100644 bob64/bootstrap.c create mode 100644 bob64/bootstrap.h create mode 100644 bob64/compiler.c create mode 100644 bob64/compiler.h create mode 100644 bob64/console.c create mode 100644 bob64/console.h create mode 100644 bob64/cpu.c create mode 100644 bob64/cpu.h create mode 100644 bob64/descriptors.c create mode 100644 bob64/descriptors.h create mode 100644 bob64/editor.h create mode 100644 bob64/efi.h create mode 100644 bob64/embedded_app.S create mode 100644 bob64/event.h create mode 100644 bob64/exec.c create mode 100644 bob64/exec.h create mode 100644 bob64/filesystem.c create mode 100644 bob64/filesystem.h create mode 100644 bob64/font.h create mode 100644 bob64/gfx.h create mode 100644 bob64/handoff.S create mode 100644 bob64/heap.c create mode 100644 bob64/heap.h create mode 100644 bob64/interrupts.S create mode 100644 bob64/interrupts.c create mode 100644 bob64/interrupts.h create mode 100644 bob64/kernel.c create mode 100644 bob64/kernel.h create mode 100644 bob64/keyboard.c create mode 100644 bob64/keyboard.h create mode 100644 bob64/libc.c create mode 100644 bob64/libc.h create mode 100644 bob64/memory.c create mode 100644 bob64/memory.h create mode 100644 bob64/mouse.c create mode 100644 bob64/mouse.h create mode 100644 bob64/paging.c create mode 100644 bob64/paging.h create mode 100644 bob64/process.c create mode 100644 bob64/process.h create mode 100644 bob64/runtime.h create mode 100644 bob64/shell.c create mode 100644 bob64/shell.h create mode 100644 bob64/snapshot.c create mode 100644 bob64/snapshot.h create mode 100644 bob64/syscall.c create mode 100644 bob64/syscall.h create mode 100644 bob64/types.h create mode 100644 bob64/window.h create mode 100644 bob64/window_server.c create mode 100644 bob64/window_server.h create mode 100644 kernel/bob_event.h create mode 100644 kernel/bob_event_queue.h create mode 100644 kernel/bob_font.h create mode 100644 kernel/bob_fs.h create mode 100644 kernel/bob_gfx.h create mode 100644 kernel/bob_gui.h create mode 100644 kernel/bob_memory.h create mode 100644 kernel/bob_native.h create mode 100644 kernel/bob_process.h create mode 100644 kernel/bob_system.h create mode 100644 kernel/bob_time.h create mode 100644 kernel/bob_wm.h create mode 100644 tests/test_bob64.c create mode 100644 tools/bob64cc.c create mode 100644 tools/test_bob64_qemu.ps1 diff --git a/BOB64_MIGRATION.md b/BOB64_MIGRATION.md new file mode 100644 index 0000000..81d2bee --- /dev/null +++ b/BOB64_MIGRATION.md @@ -0,0 +1,395 @@ +# bob64 migration status + +This document tracks the separate x86-64 OS target. `bob16` and `bob32` are +software-emulated custom instruction sets; the current `bob32` kernel is not an +x86 kernel and cannot be promoted to x86-64 by changing C integer widths. The +new target starts as an x64 UEFI application. Its opt-in handoff now takes +ownership of paging, early memory allocation, display output and a minimal shell; +the existing emulator/build outputs stay separate. + +## Implemented stages + +- `bob64/types.h` defines fixed-width scalar types and pointer/size types from + compiler-provided x86-64 definitions, with compile-time width checks. +- `bob64/boot.c` builds as a PE32+ AMD64 EFI application at the standard + removable-media path `EFI/BOOT/BOOTX64.EFI`. The image includes a PE base + relocation directory and `DYNAMIC_BASE`, so firmware may load it away from its + preferred `0x100000` image base. +- x64 UEFI transfers control in 64-bit long mode with its x64 ABI, stack and + page tables. The entry checks the maximum CPUID leaves before reading feature + bits, requires PAE and long-mode support, and confirms `EFER.LMA` before it + prints `bob64!` through UEFI text output. `bob64/cpu.c` also decodes NX + support and the CPU's physical-address width for paging setup. The safe probe + returns through firmware; the handoff variant switches to bob64-owned tables + and exits Boot Services. +- The boot entry reads the UEFI memory map through the x64 Boot Services table. + `bob64/memory.c` parses the firmware-provided descriptor stride and seeds a + sorted, coalesced first-fit allocator of 4 KiB conventional physical pages, + keeping physical addresses in `u64`, clipping ranges to the detected CPU + physical-address width, and reserving the first MiB. Allocation + records make invalid and double frees fail; the independent live-allocation + ledger supports up to 16,384 ranges, while free extents have a separate + 128-range limit. Boot reserves the replacement stack and table pool from this + allocator, and the kernel continues allocating from the preserved state. +- The x64 UEFI ABI is Microsoft's x64 ABI: integer/pointer arguments use + `RCX`, `RDX`, `R8`, and `R9`; integer/pointer returns use `RAX`; `RSP` is + 16-byte aligned at call sites with 32 bytes of caller-provided shadow space. + The compiler data model is LLP64 (`char` 8, `short` 16, `int` 32, `long` 32, + `long long` 64, pointer/`size_t` 64). bob64 code should use `u64`/`s64` and + `usize`/`isize` for explicit widths rather than assuming `long` is 64-bit. +- `bob64/paging.c` builds four-level x86-64 page tables with 4 KiB + leaves. Allocate/access callbacks keep physical page addresses distinct from + currently accessible pointers; the builder enforces the CPUID-reported + physical-address width. `bob64_page_map_range` validates canonical spans and + maps byte ranges while preserving partial-page offsets. `bob64_page_protect` + tightens leaf permissions and `bob64_page_unmap` returns the removed physical + frame and flags; callers invalidate the TLB for live edits. The host suite + walks low and upper canonical virtual addresses and physical/table addresses + above 4 GiB, and verifies writable pages can become read-only/NX, be unmapped, + and be mapped again. The handoff activates the root after enabling `EFER.NXE` + when supported; host tests cover mapping logic, while the privileged switch + still needs UEFI runtime verification. +- `bob64/bootstrap.c` composes that mapper into a bootstrap identity address + space for the loaded EFI image, a replacement stack, and a pre-reserved + contiguous page-table pool. It marks stack/pool pages NX when supported and + rejects overlapping ranges or an undersized pool. Tests verify translation + and permissions for all three regions. The EFI entry obtains the loaded-image + protocol and uses its full-width image base and size to prepare and verify + identity mappings for the actual image, an 8-page replacement stack, and a + 128-page table pool. The handoff also maps its memory-map buffer and supported + GOP framebuffer. It builds the kernel GDT and exception IDT while the image + is mapped. The default `--bob64` image still returns safely to firmware after + preparation. +- `bob64/descriptors.c` builds kernel and DPL3 user code/data GDT entries, a + full-width 64-bit TSS descriptor, the packed 10-byte GDTR/IDTR operand, and + 16-byte x86-64 IDT gates with split 64-bit handler addresses. Boot sets TSS + `RSP0` to the initial kernel stack, and the handoff loads the task register. + After heap startup, the kernel changes `RSP0` to a separate supervisor-only + privilege-transition stack so user interrupts will not overwrite the paused + kernel call stack. Each shell-launched application now gets its own zeroed + 16 KiB privilege stack; the previous TSS stack is restored before that + allocation is released. Tests verify selector values, TSS offsets/base/limit, + full-width stack replacement, alignment, DPL3 gates, IST, and gate type. +- `bob64/interrupts.S` contains 64-bit stubs for CPU exception vectors 0-31, + normalizing hardware error-code and no-error-code frames before saving all + general-purpose registers and calling the Microsoft x64 C dispatcher. The + common path restores registers and uses `iretq`. `interrupts.c` wires an IDT + to those stubs and a fatal fallback, and prints full 64-bit register values + over COM1 and the framebuffer before halting. The opt-in handoff loads the + IDT. The DPL3 vector `0x80` enters a dedicated syscall stub; runtime + exception and syscall delivery still need firmware/emulator testing. +- `bob64/kernel.c` is the first kernel-owned C entry point. It checks the + boot-information structure, active CR3, memory-map range, and stack, then + reports the 64-bit root and map details, checks the growable kernel heap, then + starts the polled shell. The filesystem and shell are still bring-up services, + not yet a general-purpose OS. +- `bob64/handoff.S` provides the Microsoft x64 ABI entry bridge: interrupts are + disabled, the kernel GDT is loaded and CS reloaded, the IDT is loaded, NXE + and CR0.WP are enabled when supported, the TSS is loaded, CR3 is switched, and execution moves + to the replacement stack before calling the kernel. The EFI boot path calls + `ExitBootServices` using a freshly acquired map key, retrying a stale key up + to three times. +- The handoff is opt-in so the original EFI probe stays available: + `build-tool --bob64-handoff` emits a distinct image and + `build-tool --bob64-handoff-test` runs host PE checks against it. Those checks + cannot prove the privileged transition works on real firmware. +- The handoff queries UEFI GOP and maps a supported RGB/BGR framebuffer into + the new address space as writable, non-executable, uncached memory. The + kernel's `bob64/console.c` draws a compact 5x7 text font, wraps and scrolls, + and mirrors output to COM1. Unsupported or invalid GOP modes retain the serial + console fallback. Host tests exercise format encoding, glyph output, and + invalid framebuffer bounds; actual display output still needs UEFI testing. +- `bob64/heap.c` provides a 16-byte-aligned, coalescing kernel heap with + `alloc`, `calloc`, and `free`. Kernel entry adopts the page allocator and + page-table pool seeded by boot, then grows the heap by mapping physical 4 KiB + pages into a 64 MiB high-half range at `0xffff900000000000`. New pages are + zeroed before use. Kernel entry smoke-tests multi-page allocations, alignment, + zeroing, writes, frees, and double-free rejection. Host tests cover splitting, + coalescing, overflow, and invalid frees. This early heap is single-core and + does not reclaim empty pages yet. +- `bob64/keyboard.c` decodes PS/2 set-1 input, including shift, caps lock, + editing keys, and Pause/extended sequences. IRQ1 now feeds a bounded 64-event + queue used by the shell and app event service after the kernel remaps the PIC; + the kernel keeps polling as a fallback if the controller is unavailable. + IRQ12 feeds a bounded mouse-event queue through the same app event service; + COM1 remains polled. Unit tests cover scan-code state, keyboard/mouse queue + behavior, and shell command/edit behavior. A 100 Hz PIT IRQ now supplies a + monotonic tick counter through the versioned syscall ABI. USB keyboards, + history and completion remain future work. +- `bob64/filesystem.c` adds a flat, volatile binary-safe filesystem backed by the + kernel heap. It supports 64-bit lengths, case-sensitive names, atomic file + replacement, listing, reads, and deletion; names reject path separators and + characters outside the safe filename set. The shell exposes `ls`, `cat NAME`, + `write NAME TEXT`, and `rm NAME`. Host tests cover replacement, invalid names, + binary NUL round-trips, and shell workflows. +- `bob64/snapshot.c` defines B64S version 1 as a pointer-free little-endian + format with 64-bit total/data lengths and a CRC-32. Restore validates version, + size, checksum, record bounds, names, and duplicate files before replacing + the live filesystem. The shell's `save` and `restore` commands keep one + checkpoint in the kernel heap for the current boot session; it is lost on + reboot. Host tests cover round-trip, empty files, replace-on-restore, + truncation, unsupported versions, checksum errors, and unchanged state after + rejected input. Disk persistence and directories remain future stages; the + app filesystem ABI supports bounded whole-file operations and ABI v10 streaming + handles with 64-bit seek positions and bounded reads/writes; hardware-backed + persistence remains outstanding. +- `bob64/exec.c` defines B64E version 1, a flat position-independent 64-bit + executable image with a versioned ABI, exact payload length, 64-bit memory + size and entry offset, page-aligned code/data boundary, payload CRC-32, and + zero-required reserved fields. The shared parser rejects malformed/truncated + images before returning a view; a contiguous copy helper preflights capacity + and address overflow, copies the image, clears the memory-only tail, and + preserves entry addresses above 4 GiB. Mapped application loading is provided + separately by `process.c`. A synthetic B64E app now runs at CPL3, writes + `bob!` through syscall v2, performs a bounded RAM-file round trip, and exits + back to the saved kernel stack. +- `bob64/abi.h` starts application ABI v1 on the same Microsoft x64 calling + convention used by the UEFI kernel: integer/pointer arguments in RCX, RDX, + R8, and R9; scalar status in RAX; 32-byte shadow space; 16-byte call-site + stack alignment; and no red zone. Entry receives one pointer to a fixed + 32-byte startup record containing a 64-bit argument count and argv pointer. + The record and its strings are app-space data, so the contract does not pass + kernel pointers. Tests check the record layout, entry call, nested calls, and + stack-passed arguments. Syscall ABI v10 defines an ABI query, character and + bounded buffer output, file reads and writes, pixel-display query/present, + blocking keyboard and PS/2 mouse events, and process exit through interrupt + vector `0x80`; user pointers are validated + against the active process root before buffer reads or writes. Display apps + submit a packed 0x00RRGGBB frame matching GOP dimensions; the kernel copies + bounded chunks into the device surface without exposing its address. Tests + cover the syscall and both GOP channel formats. + `apps/bob64_display.c` exercises the app-facing wrapper and is packaged as a + B64E image with a bounded 1024x768 static surface; runtime execution awaits + UEFI verification. +- `bob64/window.h` ports the reusable window-manager behavior to app-owned + fixed-capacity 64-bit state: nonzero 64-bit handles, full-width context + pointers, visibility, focus, z-order, hit testing, title-bar dragging, + clamping, dirty redraws, and keyboard/mouse event routing to window-local + coordinates. Host tests exercise overlap redraw, wheel routing, focus and + pointer values above 4 GiB. `apps/bob64_gui.c` is the first native desktop + on this manager. It opens a named RAM text file (or `notes.txt` by default), + lists RAM files in a separate window, supports selection/open/refresh and + confirmed deletion, plus insertion, line breaks, cursor movement, click + placement, scrolling, Ctrl+S save and an unsaved-exit prompt. It validates flat + filenames and protects an existing file over the current 4 KiB syscall limit + from accidental overwrite. The shell launches it with + `run desktop.b64e [filename]`; host tests cover the editor buffer, packaged + UI strings, file ABI and window manager. The full existing bob GUI, a file + picker and real UEFI interaction remain to be ported/verified. +- `bob64/ABI.md` records the register-preservation rules, stack alignment and + shadow-space contract, pointer ownership, and application entry shape. The + compiler's aggregate behavior follows the Microsoft x64 ABI; aggregate + returns are not part of the application-entry contract. `bob64/app.h` exposes + syscall wrappers for native C apps without kernel-internal types. The small + `bob64/libc.c` runtime provides memory and string operations with 64-bit sizes. +- `bob64/compiler.c` is the first resident x86-64 code-generation stage. The + shell exposes `cc bob.c [OUTPUT]`, which packages the accepted source directly + as B64E; `run app.b64e` launches it. The current syntax accepts `int` or + `long`, `long long`, or `int main(void)`, initialized `int`/`long`/`long long` + locals and assignments, + bounded `bob64_app_write` calls with string literals, and 64-bit integer + return expressions with parentheses, unary minus, addition, subtraction, and + multiplication. Its frame and entry wrapper follow the Microsoft x64 stack + contract; syscall ABI v10 provides exit, graphics output, whole-file and + streaming file I/O/list/delete, + and input. + The compiler recognizes `usize`/`uintptr_t` as unsigned 64-bit scalar types + and `isize`/`intptr_t` as signed 64-bit scalar types in declarations and + function signatures. These are built-in type names; typedefs and header + inclusion remain unsupported. `usize *`, `uintptr_t *`, `isize *`, + `intptr_t *`, and `long long *` map to signed/unsigned wide-pointer types with + eight-byte loads, stores, indexing and scaled pointer arithmetic. They work as local, + parameter, return, global, and struct-field types; global pointers may target + matching scalar objects. Fixed-size signed and unsigned 64-bit arrays now + support local and global storage, initialization, indexing, mutation, array + parameter decay, and eight-byte element addressing. Local arrays are limited + to 16 elements by the fixed function frame; global arrays share the 4 KiB data + page. + Function declarations and definitions can return `char *`, `short *`, `int *`, + and pointers to declared structs. Returned pointers keep all 64 bits; return + expressions must match the declared pointee type. Returning a pointer through + `long long`/`usize` remains accepted for the compiler's existing raw-address + tests. Host execution tests cover pointer identity through a prototype and a + returned string literal used by the caller. +- `bob64/process.c` adds a callback-backed B64E loader core. It reparses the + exact file before allocation, maps up to 16 MiB of app memory at + `0x0000004000000000`, keeps code user-readable/executable and read-only, and + maps data, BSS, and a 64 KiB stack writable/user/NX. It leaves an unmapped + guard page below the stack, builds a 64-bit argv array and startup record in + app memory, and prepares an ABI-aligned entry stack with shadow space. Failed + loads roll back mappings and frames; unload removes each mapping before + returning its physical frame. Host tests use physical frames above 4 GiB and + verify argument contents, permissions, zero-filled BSS, guard placement, and + rollback. The kernel wires these callbacks to its real page allocator and a + private cloned root with a 34 MiB isolated app arena. At boot, the synthetic + user app prints `bob!` and exits through the controlled syscall path. + The shell's `run NAME [ARG ...]` command now reads B64E files from the RAM + filesystem and launches them with app-owned arguments; `bob.b64e` is seeded + as an example. General app services and persistent storage remain ahead. +- `build-tool --bob64` builds only the new EFI image. `build-tool --bob64-test` + also validates the PE machine, PE32+ header, EFI application subsystem, + 64-bit type sizes, synthetic pointer arithmetic above 4 GiB, and the presence + of base relocations for firmware-selected load addresses. It also exercises + four-level mapping, translation, permissions, canonical-address checks, + physical-width limits in both allocator and page tables, multi-page range + mapping, protect/unmap/remap behavior, duplicate-map rejection, bootstrap identity mappings, synthetic + CPUID feature decoding, 64-bit GDT/IDT layouts, and exception-stub wiring. + +## Still required by the migration goal + +- [x] Boot the handoff image under x64 UEFI emulation. QEMU/OVMF verified the + long-mode entry, `ExitBootServices`, owned CR3, kernel heap, framebuffer + console, COM1 diagnostics, ring-3 smoke app, and shell. A runtime script + repeats the boot and checks its serial milestones. +- [x] Exercise ring-3 syscalls and user exception recovery after loading the + GDT/IDT and new CR3. A deliberate invalid opcode was diagnosed with the full + register frame and returned to the kernel; the corrected smoke app now exits + normally. The IDT now also contains PIT, PS/2 keyboard, and PS/2 mouse IRQ + handlers; runtime IRQ-path verification remains pending below. +- [x] Verify actual ring-3 text protection and data NX behavior. QEMU runtime + probes attempt to write the read-only executable page and execute the NX data + page; both receive the expected user page-fault error bits and return to the + kernel. The kernel also checks that the stack guard is unmapped. +- [ ] Add dynamic page-table-pool growth, heap locking, and reclamation of empty + heap pages. The bootstrap identity map favors bring-up simplicity. +- [x] Verify GOP, COM1, PS/2 keyboard, and mouse input under UEFI emulation. + QEMU showed mouse movement and a click selecting a file-list row; keyboard + input launched/closed the desktop and created a third window. +- [ ] Verify the new IRQ1 keyboard and IRQ12 mouse paths under UEFI emulation. + Host tests cover the IDT gates and bounded event queues; QEMU verification is + pending. +- [x] Add a 100 Hz PIT timer IRQ, tick counter, and user tick query. The timer + tick path is covered by host syscall tests; runtime QEMU verification remains + pending alongside keyboard/mouse IRQ checks. +- [ ] Add USB keyboard support and command history/completion. COM1 remains + polled. +- [ ] Add persistent storage for B64S snapshots. ABI v10 now supplies bounded + handle-based streaming reads/writes, 64-bit absolute seeks, create/truncate/ + append modes, and per-app handle cleanup; physical persistence remains open. +- [ ] Port remaining device services and add USB keyboard support. +- [x] Add typed pointer returns to the resident x86-64 compiler for + `char *`, `short *`, `int *`, and declared struct pointers. Tests cover + prototype calls, string literal and struct pointer returns, and rejection of + incompatible pointee types. +- [x] Add `void` helper functions and scalar `char` returns to the resident + compiler. Void helpers accept explicit `return;` or fall through, can be called + as statements, and are rejected in value contexts. Scalar `char` returns + sign-extend from eight bits; main remains required to return a value. +- [x] Add typed pointers to `usize`/`uintptr_t` and `isize`/`intptr_t` values. + Local/global/struct-field storage, parameters, returns, dereference, indexing, + assignment, and 8-byte-scaled arithmetic are covered, including synthetic + pointer values above 4 GiB. +- [x] Add fixed signed and unsigned 64-bit arrays with local/global storage, + initialization, indexed reads/writes, and array-parameter decay. Local arrays + are bounded to 16 elements and global data to the existing 4 KiB page. + File-scope `short`, `int`, `long`, `char`, and `long long` scalars plus bounded + fixed `short`/`int`/`char` arrays now use initialized writable B64E data and + RIP-relative x64 access across functions. Global `short *`/`int *`/`char *` + initializers may target + previously declared arrays or string literals. Named structs define aligned + scalar/pointer layouts and support local/global instances plus `.`/`->` field + loads/stores. Struct arrays, nested structs, typedefs, and multiple translation + units remain unsupported. Limits are 8 struct types, 16 fields per type, 16 + global objects, and the single 4 KiB data page. + Local fixed `short`/`int` arrays, `short *`/`int *` locals, + dereference/indexing, scaled pointer arithmetic and pointer differences, and + local brace initializers are + implemented. `short` (16-bit), `int`/`long` (32-bit), and `long long` + (64-bit) helper functions and matching prototypes before or after `main` + support nested/forward + calls with up to sixteen scalar, `short *`/array, `int *`/array, `char *`, + `usize *`, `isize *`, or struct-pointer parameters, following the Microsoft + x64 register and stack argument layout. + Compound blocks and `for` initializers now have lexical local scopes with + shadowing and stack-slot reuse after scope exit. + NUL-terminated string + literals, signed 8-bit `char` locals/parameters, escaped character constants, + byte-scaled `char *` indexing, stores, dereference, and arithmetic, plus local + `char` arrays with string or brace initializers, now support resident C string + traversal and mutable text buffers. Struct pointer parameters can be passed + through helper calls using the Microsoft x64 argument ABI; helpers can read + and write fields through `->`. + `if`/`else` and `while` support signed + relational/equality comparisons, and expressions support unary `!` plus + short-circuit `&&`/`||`. Basic `for` loops now emit initialization, condition, + body, and scalar assignment update code. `break` and `continue` patch to the + nearest loop; `for` continue enters its update clause. Early `return` + statements work inside branches and loops; the subset still requires a final + return at the end of each function. +- [x] Add a kernel-owned per-app window manager and port the desktop's file and + editor windows to its surfaces. Syscall ABI v10 creates, focuses, destroys, + validates and copies app surfaces, composites z-order, routes input with + 64-bit handles and local/screen coordinates, and releases the session on app + exit. Concurrent apps are still not displayed together. +- [x] Run the native desktop under QEMU/OVMF at 1280x800. Both managed windows + rendered; keyboard input created a third window, Escape returned to the + shell, and Ctrl+S saved editor text through the file syscall. The full screen + and B64S shell commands were also exercised in the same UEFI session. +- [ ] Port the remaining applications to the kernel window API. Syscall ABI v10 + also provides bounded file reads/writes/list/delete, console I/O, + full-screen presentation, blocking PS/2 keyboard/mouse events, ABI query, and + process exit. The host `bob64cc` + bridge continues to package the broader C subset supported by GCC. +- [ ] Port the remaining existing applications and full GUI/widget behavior; + the current native text editor is an initial, limited desktop milestone. +- [x] Run the kernel-generated ring-3 `bob!` app under x64 UEFI emulation. The + resident compiler also compiled and launched `bob.c`; B64S `save`/`restore` + recovered a deleted file, and the native GUI opened and saved an editor file. +- [ ] Complete the full acceptance flow and add runtime tests for broader + calling-convention/stack cases, hardware interrupts, mouse input, and + persistent B64S storage. The ring-3 app image runs at a virtual address above + 4 GiB; host tests also cover synthetic high addresses and broad ABI/memory + cases. +- [x] Verify bob64 boots in x64 UEFI emulation and performs its own kernel + initialization without executing 32-bit kernel or app code. The broader + migration remains active: the resident C subset, devices, persistence, and + existing application ports still need work. + +## Build and test + +```text +build-tool --bob64 +build-tool --bob64-test +build-tool --bob64-handoff +build-tool --bob64-handoff-test +tools/test_bob64_qemu.ps1 -QemuPath -OvmfCodePath +``` + +The safe output goes to `build/bob64/EFI/BOOT/BOOTX64.EFI`; the opt-in handoff + image goes to `build/bob64-handoff/EFI/BOOT/BOOTX64.EFI`. Host tests validate +the PE/COFF architecture and subsystem, 64-bit pointers, synthetic addresses + above 4 GiB, memory-map descriptor strides, page allocation/coalescing, + allocation-ledger capacity, invalid free handling and overflow checks. The + PowerShell QEMU test performs a real OVMF boot of the handoff image and checks + serial markers through the kernel shell; it needs the QEMU executable and + `edk2-x86_64-code.fd` paths supplied by the caller. The full script does not + replace testing on physical UEFI hardware. + +## Memory layout boundary + +The current owned paging stage uses four-level tables. The image, bootstrap +stack, table pool, memory map, and supported GOP framebuffer are mapped at +identity addresses in the lower canonical half. Physical addresses below 1 MiB +remain reserved. The early heap occupies a 64 MiB window beginning at +`0xffff900000000000`. The B64E loader reserves a lower-half user image arena of +16 MiB beginning at `0x0000004000000000`; its 64 KiB user stack begins at +`0x0000004002001000`, with an unmapped guard page at `0x0000004002000000`. +The kernel smoke test clones the active root, privately copies the page-table +branch covering a 34 MiB image-and-stack arena, clears stale mappings in that +arena, and switches CR3 before loading and unloading a synthetic app. Other +kernel mappings remain shared. The kernel enters the synthetic app at CPL3 +using an `iretq` frame. The app can query the syscall ABI, print characters +through `int 0x80`, and exit through a controlled return to the saved kernel +stack. The user-entry bridge enables interrupts for apps and restores the +caller's prior IF state when the app exits. The boot smoke app checks that the +keyboard IRQ path remains enabled after a user process returns. The versioned +syscall ABI also includes file handles and window services. +The fallback kernel privilege stack and each app's dedicated 16 KiB interrupt +stack are allocated from the supervisor-only heap. App runs also push a bounded +syscall context that preserves the parent's callbacks, user page table, scratch +buffers, and file handles; each app owns a separately allocated window-server +session. The user-entry return bridge still uses singleton state, so nested app +execution is not enabled yet. +The volatile +filesystem and B64S checkpoint live in the kernel heap; there is no full +physical direct map or filesystem mapping. diff --git a/C_IMPLEMENTATION.md b/C_IMPLEMENTATION.md index fe640c9..0eb066a 100644 --- a/C_IMPLEMENTATION.md +++ b/C_IMPLEMENTATION.md @@ -583,3 +583,55 @@ The bob32 resident compiler now accepts one-dimensional array parameters, adjust Started the app-side standard library with `kernel/bob_string.h`: basic string operations, whitespace detection, overflow-checked signed decimal/hex parsing, bounded integer formatting and quote-aware in-place tokenization. Runtime tests exercise edge cases in bob32, and a compiled app using the header is imported, launched, snapshotted, restored and run again from the bob32 filesystem. Full suites: CPU 203, OS/compiler 1,840, console 28. Native bob32 apps can now use `int main(int argc, char **argv)`. The OS shell accepts quoted arguments after an imported app name, preserves empty strings and backslash escapes, and supplies the guest filename as `argv[0]`. A compiled app checks its argument count and values—including a word with spaces and an empty argument—through the real import/run path. Full suites: CPU 203, OS/compiler 1,844, console 28. + +Added a version 1 native OS service through `bob_fs.h` for filesystem metadata and text operations, plus basic memory/filesystem system information. Added native `echo`, `ls`, `cat`, `sysinfo`, and `notes` examples. Integration tests exercise the utilities, create a note, save a B32S snapshot, restore it in a new emulator process, then read and delete it. Full suites: CPU 203, OS/compiler 1,874, console 28. + +Added a version 1 graphics and input boundary through `bob_gfx.h` and `bob_event.h`. The terminal backend provides an 80x25 double-buffered character-cell surface with colors, pixels, rectangles, lines, text and transparent bitmap-cell blits. Blocking event wait delivers typed characters and special key presses, with release/mouse event types reserved. The graphics demo draws, waits for a test key, leaves graphics mode and returns to the shell. Full suites: CPU 203, OS/compiler 1,880, console 28. + +## bob64 user pixel-surface milestone + +bob64 syscall ABI v3 adds a display query and a protected full-screen surface present call. Apps submit packed 0x00RRGGBB pixels; the kernel validates the entire range in the isolated user page table, then copies in 1024-pixel chunks and converts channels for GOP RGB/BGR modes without exposing the device pointer. bob64_app_get_display and bob64_app_present wrap the services. The new apps/bob64_display.c demo paints a bounded 1024x768 gradient and writes bob!; build/test parses its B64E image. Tests verify dimensions, both GOP channel layouts, invalid mappings and size mismatches. build-tool --bob64-test and --bob64-handoff-test both pass. Actual display presentation remains unverified until UEFI runtime testing. +## bob64 app input-event milestone + +Syscall ABI v5 defines a fixed 44-byte BOB64_EVENT and blocking app-owned input delivery. The PS/2 set-1 decoder emits key-down/up events, ASCII characters, Shift/Caps/Control/Alt state and extended key identities while preserving shell input. A bounded PS/2 mouse driver decodes movement, button transitions, IntelliMouse wheel packets and extended buttons, clamps coordinates to the framebuffer, and routes events through the same validated app buffer. apps/bob64_display.c stays on screen until Escape. Host tests cover keyboard modifiers, mouse packet signs/clamping/buttons/wheel, syscall delivery and invalid user pointers. Both bob64 host suites pass; UEFI device execution remains unverified. + +## bob64 user-space window-manager milestone + +Added bob64/window.h as a 64-bit-clean app-owned port of the existing fixed-capacity window manager. It stores 64-bit handles and context pointers, preserves focus/z-order/visibility and dirty-redraw behavior, hit-tests and clamps windows, supports title-bar dragging, and routes keyboard, mouse, and wheel events in local coordinates. Tests exercise overlapping redraws, hidden-window focus, drag/release behavior, wheel routing, stale handles, and synthetic app pointers/handles above 4 GiB. bob64 graphics and handoff test suites both pass and print bob!. The existing desktop application and widget drawing layer still need porting and UEFI runtime verification. + +## bob64 native desktop editor milestone + +Expanded `apps/bob64_gui.c` from a windowing demo into a small usable desktop app. It launches from the shell as `run desktop.b64e [filename]`, defaults to `notes.txt`, and supports mouse cursor placement, keyboard insertion, Backspace/Delete, arrow-key movement, newline insertion, viewport scrolling, Ctrl+S saves and a two-Escape unsaved-exit prompt through syscall ABI v5. Filenames are validated against the flat filesystem's allowed set. Raised the bounded whole-file console/file syscall buffer to 4 KiB and moved its transfer scratch into kernel static storage to keep the 16 KiB privilege stack clear. Added `bob64/editor.h` for a bounded 4 KiB editing buffer and host regression tests for 4 KiB syscall read/write across page boundaries, user-range validation, insertion, deletion, movement, wrapping and line handling. Files over the current syscall buffer limit cannot be overwritten by this app. The generated app is embedded in the UEFI image and installed as `desktop.b64e`; both `--bob64-test` and `--bob64-handoff-test` pass and print `bob!`. Actual UEFI input/display and the full existing GUI port remain unverified. + +The resident bob64 compiler now supports fixed local `int` arrays, `int *` +locals, array decay, address-of/dereference, indexed loads/stores, and scaled +pointer addition/subtraction. It rejects pointer multiplication and mismatched +pointer assignments/initializers. Runtime tests execute generated code for +array indexing, both pointer-addition operand orders, 4-byte element scaling, +pointer differences and a stack pointer above 4 GiB; negative tests check +invalid pointer arithmetic and assignment. Local arrays also accept scalar +brace initializers with trailing commas and zero-fill for omitted elements; +excess elements are rejected. Integer and `long long` helper functions may +appear before or after `main`, with forward and nested calls using up to eight +parameters. The first four use Microsoft x64 argument registers and later ones +use the caller's stack area; scalar and `int *`/array parameters are stored in +function-local stack slots, and array parameters support indexing. Tests cover +generated-code execution for pre-main definitions, 64-bit helper returns, array +parameters, nested calls, all four argument registers, stack-passed scalar and +pointer arguments, argument-count rejection, and the established `bob!` smoke +path. Function prototypes now contribute signatures during a top-level pass; +definitions must match their return type and parameter count/types, and calls +to declarations without definitions are rejected. Tests cover unnamed prototype +parameters, 64-bit prototype returns, and prototype/definition conflicts. The +statement parser now emits tested +`if`/`else` and `while` branches, and signed integer comparisons for `==`, `!=`, +`<`, `<=`, `>`, and `>=`; braced blocks share one function namespace. Unary +`!` and short-circuit `&&`/`||` are supported, with regression tests proving +skipped branches do not execute pointer-mutating calls. Lexical scopes and +return types other than `int` or `long long` remain unsupported. +C-style `for` loops now support optional +initialization/condition clauses and a scalar assignment update. Nested loop +contexts patch `break` to the nearest exit and `continue` to the while condition +or for-update block; tests exercise nested targets and reject either statement +outside a loop. Conditional early returns emit the function epilogue and +are tested with a signed absolute-value helper. diff --git a/C_OS.md b/C_OS.md index 13469f0..99b65cc 100644 --- a/C_OS.md +++ b/C_OS.md @@ -47,6 +47,85 @@ name and `argc` includes it. Pass arguments with `run myapp first "two words"`; quotes group spaces and backslash escapes the next character. Empty quoted arguments are preserved. This applies to imported guest files; direct host-path `run32` launches currently start without command-line arguments. + +Native applications can use `bob_fs.h` for guest RAM files. Its version 1 +service supports listing names/kinds/sizes, direct kind lookup by filename, +reading and writing text files and +raw bob16/bob32 program words, and deleting files. Text writes are bounded to +the text-file limit; binary writes accept only program kinds. Native B32K apps +must enter storage through validated import. The OS keeps filesystem tables +private to the kernel. See [the native app examples](apps/README.md) +for `echo`, `ls`, `cat`, `sysinfo`, and the snapshot-friendly `notes` app. +`launcher` lists stored native bob32 applications and runs one with arguments; +native apps can use `bob_process.h` to launch another stored app and receive its +exit code. The emulator preserves the suspended app's memory while a child runs. + +`bob_memory.h` provides a small caller-owned word arena for temporary app data. +Give it an integer buffer, allocate in target words, inspect used/remaining space, +and reset it for reuse. Allocation returns null for invalid requests or when the +buffer is full; it reserves no global OS heap. + +Native apps can include `bob_time.h` to read UTC seconds through the versioned +OS-service boundary. The result is returned as low and high 32-bit words. +`bob_system.h` reports the system-service version, cell-framebuffer presence +and size, and whether keyboard and mouse input are available. `sysinfo` displays +these device capabilities alongside the filesystem and application-memory +usage. +For convenience, `bob_native.h` includes the common string, memory, filesystem, +process, time, system-capability, and input-event APIs. Add `bob_gfx.h` and +`bob_gui.h` separately when building graphical apps. + +`bob_gfx.h` provides the first graphics abstraction: apps draw into an 80x25 +cell framebuffer, then present it through the emulator’s terminal backend. +The API includes resolution, pixels, rectangles, lines, text, transparent +bitmap cells with per-cell foreground colors, clear, present and leave. +`bob_font.h` adds a 5x7 bitmap text renderer for uppercase letters, digits, +space, and common punctuation. +`apps/graphics_demo.c` draws a sample +screen, waits for a key through `bob_event_wait`, and returns to the shell. +The GUI demo's Window B includes a keyboard- and mouse-driven native app +launcher; it runs stored apps through `bob_process.h` and shows their exit status. +Press `?` for a bitmap-font help panel; Escape or its Close button returns to +the desktop. +Event version 1 delivers character and special-key down/up events. On Windows +console input it also delivers mouse movement and button transitions with +screen-cell coordinates, plus signed mouse-wheel deltas. `bob_event_wait` +blocks; `bob_event_poll` checks the console queue without blocking. Redirected +input remains character based and is consumed by the blocking path. This +cell-based backend establishes the app boundary before adding a true pixel +surface. +`bob_event_queue.h` provides a caller-owned FIFO for buffering these events; +overflow is reported without overwriting queued input. +`bob_wm.h` provides the reusable bob32 window manager. Applications give it fixed +arrays for window records and stacking order; it owns allocation, visibility, +focus, z-order, hit testing, title-bar dragging, event routing, and dirty-window +tracking. `bob_wm_dispatch` returns the window ID for an event, routes keyboard +input only to the focused visible window, and rewrites mouse coordinates to be +relative to the recipient. `bob_wm_begin_draw` and `bob_wm_next_dirty` return +visible dirty windows in stacking order; moving, hiding, raising, or destroying +a window requests a safe full redraw, while content invalidation marks the +affected window and overlaps. `bob_gui.h` adds reusable window, button, +popup-menu, single-line text-field, and multiline text-area widgets. +`apps/gui_demo.c` uses the manager for its editor and file-browser windows and +draws only the dirty windows during normal interaction; modal help, launcher, +and menu panels use full redraws. It draws a desktop +with a multiline text editor and file browser. The editor starts with `new.txt` +and `bob!`, supports mouse caret placement, insertion, deletion, Enter for new +lines, arrow/Home/End navigation, vertical movement, mouse-wheel scrolling, +and horizontal scrolling for long lines. Tab cycles through the filename field, +text area, and file browser; Ctrl+S saves the current text file. Press `e` in +the file browser to load the selected text file into the editor, then Ctrl+S to +save changes. The browser immediately lists the saved file and can preview or +delete text files with confirmation. Clicking a window raises it, dragging its +title bar moves it, and Escape returns to the +shell. Dragging is clamped to +the screen edges. A clickable button in Window A focuses Window B. Window B lists guest filesystem entries and previews selected text files; use +`n`/`p` or the mouse to change selection and Up/Down or `u`/`d` to scroll the +preview. Press `x` to show Yes/Cancel controls; click one or press `y`/`n`. +Window B also has a File popup opened with `m` or by clicking its title area; +the menu supports keyboard and mouse selection to open or delete the selected +text file, or close the popup. It follows Window B when dragged and clamps to +the screen edges. Set `BOB16_TRACE_FAULT=1` before launching the emulator to log the address and instruction when a supervised application faults. The updated emulator also accepts `bob.exe --os` from that directory to boot @@ -119,14 +198,15 @@ In a native Windows console, the shell supplies editing and redraw itself: | Ctrl+D / Ctrl+Z | End input | Completion operates on the word at the end of the line. Type more characters -when matches are ambiguous. History is session-only, includes failed commands, +when matches are ambiguous. The `history` builtin lists the same four recent +commands. History is session-only, includes failed commands, and skips consecutive duplicates. `edit` opens its own full-screen view in a Windows console. Redirected input emits no redraw or candidate lists. Other terminals use ordinary input; full interactive key handling currently targets the native Windows console. The RAM filesystem has eight slots and names up to 23 characters. bob16 keeps -eight fixed 511-word slots. bob32 packs files into 4,096 words total; text and +eight fixed 511-word slots. bob32 packs files into 8,192 words total; text and resident programs remain limited to 511 words, while native apps use six metadata words plus payload and a terminator, sharing space with other files. A character occupies one word. `bob.c` occupies one slot initially. Unsaved @@ -168,6 +248,8 @@ the parent directory must already exist. Messages mention this override. Restoring replaces **all** RAM files; use `save` first if current files matter. An invalid, truncated, corrupt or unreadable snapshot leaves RAM unchanged. The snapshot includes text and program files, not heap allocations or history. +Current bob32 snapshots use B32S v3 for the 8,192-word filesystem; B32S v1 +fixed-slot and v2 packed snapshots remain readable and migrate on restore. Native programs contain kernel helper addresses. If the kernel image differs from the one used to save, restore keeps text and omits binary programs. @@ -330,7 +412,7 @@ console/arithmetic routines and belong to the kernel build that compiled them. In bob32 mode the same syntax emits native 32-bit instructions and kind-2 RAM program files, which can be run with `run` and retained in B32S snapshots. B32 resident programs start at `0x20000` and use variables at `0xF0000..0xF000F`; -their output can use the remaining shared 4,096-word filesystem space. Source +their output can use the remaining shared 8,192-word filesystem space. Source text files remain limited to 511 words. In bob16 mode files remain kind 1 and use 16-bit integers and the `0xA000` program region. The bob32 shell also runs kind-1 legacy programs at `0xC200`, clear of the expanded kernel image. @@ -376,8 +458,9 @@ what fits in a single command line; use the resident compiler for larger program | `0xA000..0xCFFF` | Loaded bob16 compatibility program at `0xC200..0xCFFF` | | `0xD000..0xDFFF` | bob32 heap and compatibility stack region | | `0xE000..0xEFFF` | Editor/compiler scratch, history and shell stack | -| `0xF000..0xFFFF` | Packed bob32 RAM filesystem contents | -| `0x10000..0x1FFFF` | Native bob32 kernel code, globals and strings | +| `0xF000..0xFFFF` | bob16 file contents; bob32 scratch space | +| `0x10000..0x1DFFF` | Native bob32 kernel code, globals and strings | +| `0x1E000..0x1FFFF` | Protected packed bob32 filesystem contents | | `0x20000..0xEFFFF` | Supervised native bob32 program entry/code region | | `0xF0000..0xFFFFF` | Native app data and compiler variables; stack starts at `0x100000` | diff --git a/Makefile b/Makefile index 44261cf..b4be13b 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,7 @@ CC ?= gcc +BOB64_CC ?= x86_64-w64-mingw32-gcc CFLAGS ?= -std=gnu11 -O2 -Wall -Wextra -Werror -.PHONY: all c-os test +.PHONY: all c-os test bob64 bob64-test bob64-handoff bob64-handoff-test bob64cc bob64-app-test all: $(CC) $(CFLAGS) tools/build.c -o build-tool @@ -11,3 +12,27 @@ c-os: all test: all ./build-tool --test + +# x86-64 UEFI build, isolated from the bob16/bob32 emulator targets. +bob64: + $(CC) $(CFLAGS) tools/build.c -o build-tool + BOB64_CC="$(BOB64_CC)" ./build-tool --bob64 + +bob64-test: bob64 + BOB64_CC="$(BOB64_CC)" ./build-tool --bob64-test + +# Opt-in destructive-to-firmware-services kernel handoff build. +bob64-handoff: + $(CC) $(CFLAGS) tools/build.c -o build-tool + BOB64_CC="$(BOB64_CC)" ./build-tool --bob64-handoff + +bob64-handoff-test: + $(CC) $(CFLAGS) tools/build.c -o build-tool + BOB64_CC="$(BOB64_CC)" ./build-tool --bob64-handoff-test + +bob64cc: + $(CC) $(CFLAGS) tools/bob64cc.c -o bob64cc + +bob64-app-test: bob64-test bob64cc + BOB64_CC="$(BOB64_CC)" ./bob64cc apps/bob64_smoke.c build/bob64-app/smoke.b64e + ./build/test_bob64 build/bob64/EFI/BOOT/BOOTX64.EFI build/bob64-app/smoke.b64e diff --git a/README.md b/README.md index 1a33a39..500932a 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,10 @@ regenerate BASM after editing the C kernel, or build the binary boot workflow. The OS has a shell, RAM files, allocation, program loading, and a resident C compiler. Its tools are written in C; no Python is required. +An experimental x86-64 UEFI target is built separately with `build-tool --bob64`; +see [the bob64 migration status](BOB64_MIGRATION.md). It does not replace the +existing custom-CPU bob16/bob32 emulator. + extremely simple custom 16 bit cpu emulator and assembler as seen on youtube: https://youtu.be/tlIqosU75CQ?is=ZAVWsYRDMPrUKOej \ use at your own risk! code is thoroughly untested so if you find any bugs let me know asap so i can fix them asap diff --git a/apps/README.md b/apps/README.md new file mode 100644 index 0000000..8dc2c29 --- /dev/null +++ b/apps/README.md @@ -0,0 +1,111 @@ +# Native bob32 applications + +Build an application from the repository root: + +```text +gcc -E -P -nostdinc -undef -I kernel apps/notes.c -o build/notes.i +build/bobcc build/notes.i build/notes.basm build/notes.b32 --wide-app +``` + +Use the same two build commands with `apps/graphics_demo.c` and the +`build/graphics_demo` output names to build the interactive canvas example. +Import it once as `graphics`, then run `run graphics`; it waits for a key and +returns to the shell. + +Build `apps/gui_demo.c` the same way to try the desktop prototype. The larger +editor starts with `new.txt` and `bob!` in a filename field and multiline text +area. Click either field to place the caret, or use Tab to cycle through the +filename, text-area, and file-browser focus. In the browser, select a text file +and press `e` to load it; Ctrl+S saves the text back to the guest filesystem. +Enter inserts a newline. Escape returns to the shell. On a Windows console, +click a window to raise and focus it or drag its title bar to move it. +`kernel/bob_wm.h` is the shared window manager used by the GUI demo. It owns +fixed-capacity window records, focus, stacking, hit testing, title-bar drag +capture, event routing, screen clamping, and dirty redraw tracking. Apps provide +the manager's fixed storage arrays and use `bob_wm_dispatch` to route an event; +the returned window ID identifies its recipient, and mouse coordinates in the +routed event are window-local. Call `bob_wm_invalidate` when application content +changes, then draw IDs returned by `bob_wm_next_dirty` in stacking order. +`kernel/bob_gui.h` contains reusable window-frame, button, menu, single-line +text-field, and multiline text-area widgets. Drawn windows have framed borders +and a distinct title strip. +The `bob_gui_button_draw` and `bob_gui_button_event` helpers provide a reusable +clickable button with hover and pressed states. The demo button focuses Window +B on a left click, and the bob32 test suite exercises hit-testing, dragging, +left-button activation, and release-outside behavior with synthetic events. +Overlapping-window hit-testing and raising are also tested. +The text-field helpers support click-to-position, insertion, Backspace/Delete, +arrow/Home/End navigation, caret drawing, and horizontal scrolling. The text +area supports multiline insertion, vertical movement with column preservation, +click-to-position, caret visibility, and mouse-wheel scrolling. Native bob32 +fixtures check text and cursor state, including wheel-scroll bounds. +The popup menu has fixed-stride labels, keyboard selection, Enter/Escape, and +mouse hover/click activation. Window B opens it from the File title area or +with `m`; its actions open the selected text file, start delete confirmation, +or close the menu. Popup placement follows Window B when it is dragged and +clamps the menu inside the 80x25 screen; widget tests cover edge and invalid +screen placements. +Window B lists guest filesystem entries and previews the selected text file; +`n`/`p` and mouse clicks change the selection, while Up/Down or `u`/`d` scroll +the preview. On Windows, the mouse wheel scrolls the editor or preview and +changes file selection when over the list. Press `x` to open an +on-screen Yes/Cancel prompt; click a button +or press `y`/`n` to confirm or cancel. +The GUI integration test creates a long `gui.txt`, scrolls beyond the initial +preview, checks a unique trailing marker, confirms deletion, and verifies the +file can no longer be read. It also creates `new.txt` from the GUI, snapshots +the guest filesystem, restores it in a second emulator process, and reads the +saved contents with `cat`. A separate integration test loads a two-line text +file, edits and saves it through the GUI, then checks the saved newline and text +with `cat`. + +Start the bob32 OS, import the image, and use it from the guest filesystem: + +```text +import32 build/notes.b32 notes +run notes put journal "bob! a saved note" +run notes edit journal "bob! updated note" +run notes add journal "another line" +run notes show journal +ls +save +``` + +`notes edit NAME [TEXT]` creates or replaces a text note, while +`notes add NAME [TEXT]` appends a line (or prompts for one). `notes` protects +binary and executable files from note-specific commands. It also supports +`run notes delete journal`. The `echo` app prints its +arguments, `ls` lists guest files and their kinds/sizes, and `cat FILE` displays +a text file. `sysinfo` reports application memory, filesystem usage, display +dimensions, and keyboard/mouse availability. Import +each image once; the application and its data are preserved by B32S snapshots. +`cat FILE` preserves existing trailing newlines and only adds a line break when +nonempty file contents have no final newline. + +Build `apps/launcher.c` with the same commands to list stored native apps or +start one with arguments. For example, `run launcher echo "a saved note"` +starts `echo` as a child app and reports its exit code. Native apps can call +`bob_app_run(name, arguments, &exit_code)` from `bob_process.h` directly. +The GUI demo also has a small application-launcher panel: focus Window B and +press `a`, choose a stored app with `n`/`p` or the arrow keys, and press `r` or +click Launch. The desktop resumes and displays the child exit status. +Press `?` for a bitmap-font help overlay with the desktop shortcuts; Escape or +its Close button returns to the desktop. Launcher and help panels clear the +desktop canvas behind them so their contents remain readable. + +`graphics_demo` uses the version 1 `bob_gfx.h` canvas API. Its first backend is +an 80x25 character-cell framebuffer with colors, filled rectangles, lines, +text, transparent bitmap cells (including per-cell colors), and explicit presentation. The same app can +later target a pixel renderer without changing its draw calls. +Include `bob_font.h` when an app needs the opt-in 5x7 bitmap text renderer. +The demo waits through `bob_event.h`, a blocking event interface that currently +normalizes typed characters, special-key presses/releases, mouse movement, and +mouse-button transitions when the Windows console provides those records. + +Apps use `bob_fs.h` for guest file operations and `bob_string.h` for string and +number helpers. The filesystem service has a versioned request protocol and +keeps guest RAM tables private from application code. +`bob_event.h` provides blocking wait and nonblocking poll operations, while +`bob_event_queue.h` provides an optional caller-owned FIFO when an app needs to +buffer or defer events. A full queue reports overflow without dropping an +earlier event. diff --git a/apps/bob64_demo.c b/apps/bob64_demo.c new file mode 100644 index 0000000..09a8894 --- /dev/null +++ b/apps/bob64_demo.c @@ -0,0 +1,4 @@ +int main(void) { + bob64_app_write("bob!", 4); + return 0; +} diff --git a/apps/bob64_display.c b/apps/bob64_display.c new file mode 100644 index 0000000..7c60f9f --- /dev/null +++ b/apps/bob64_display.c @@ -0,0 +1,28 @@ +#include "../bob64/app.h" + +#define DISPLAY_LIMIT_WIDTH 1024u +#define DISPLAY_LIMIT_HEIGHT 768u + +static u32 pixels[DISPLAY_LIMIT_WIDTH*DISPLAY_LIMIT_HEIGHT]; + +s64 bob64_app_main(const BOB64_APP_STARTUP *startup) { + u32 width,height; + BOB64_EVENT event; + if(!startup||startup->AbiVersion!=BOB64_APP_ABI_VERSION|| + bob64_app_query_abi()!=BOB64_SYSCALL_ABI_VERSION|| + bob64_app_get_display(&width,&height))return -1; + if(!width||!height||width>DISPLAY_LIMIT_WIDTH||height>DISPLAY_LIMIT_HEIGHT) + return -2; + for(u32 y=0;y=BOB64_GUI_MAX_WINDOWS||surface_allocations[slot].Used||!width||!height|| + (u64)width*height>BOB64_GUI_SURFACE_PIXEL_CAPACITY)return 0; + bytes=(usize)width*height*sizeof(u32); + for(;;) { + usize next=sizeof(pixels); + int next_slot=-1; + for(u32 i=0;i=candidate&& + surface_allocations[i].Offset=sizeof(pixels))return 0; + } + if(candidate>sizeof(pixels)||bytes>sizeof(pixels)-candidate)return 0; + surface_allocations[slot].Offset=candidate; + surface_allocations[slot].Bytes=bytes; + surface_allocations[slot].Used=1; + return pixels+candidate/sizeof(u32); +} + +static void gui_surface_release(u32 slot) { + if(slot>=BOB64_GUI_MAX_WINDOWS)return; + surface_allocations[slot].Offset=0;surface_allocations[slot].Bytes=0; + surface_allocations[slot].Used=0; +} + +static BOB64_WINDOW_HANDLE gui_create_window(s32 x,s32 y,u32 width,u32 height, + const char *title) { + BOB64_WINDOW_HANDLE kernel_handle; + BOB64_WINDOW_HANDLE app_handle; + BOB64_WINDOW *window; + u32 slot=0; + u32 *surface; + while(slot=BOB64_GUI_MAX_WINDOWS||!(surface=gui_surface_allocate(slot,width,height))) + return 0; + kernel_handle=bob64_app_window_create(x,y,width,height); + if(!kernel_handle||(s64)kernel_handle<0) { + gui_surface_release(slot);return 0; + } + manager.NextHandle=kernel_handle; + app_handle=bob64_wm_create(&manager,x,y,width,height,(void *)title); + if(app_handle!=kernel_handle) { + if(app_handle)bob64_wm_destroy(&manager,app_handle); + bob64_app_window_destroy(kernel_handle);gui_surface_release(slot);return 0; + } + window=bob64_wm_find(&manager,app_handle); + slot=(u32)(window-windows); + graphics[slot].Pixels=surface;graphics[slot].Width=width; + graphics[slot].Height=height; + graphics[slot].Capacity=(usize)BOB64_GUI_MAX_WIDTH*BOB64_GUI_MAX_HEIGHT; + return app_handle; +} + +static int gui_destroy_window(BOB64_WINDOW_HANDLE handle) { + u32 slot=0; + while(slot=BOB64_GUI_MAX_WINDOWS)return -1; + if(bob64_app_window_destroy(handle))return -1; + if(bob64_wm_destroy(&manager,handle))return -1; + gui_surface_release(slot); + return 0; +} + +static void gui_focus_window(BOB64_WINDOW_HANDLE handle) { + if(bob64_wm_focus(&manager,handle)||bob64_app_window_focus(handle)) + gui_copy(editor_status,"FOCUS FAILED",sizeof("FOCUS FAILED")); +} + +static int gui_load_file(const BOB64_APP_STARTUP *startup) { + const char *requested="notes.txt"; + usize length=sizeof("notes.txt")-1; + s64 result; + if(startup->ArgumentCount>1) { + requested=startup->Arguments[1]; + length=gui_length(requested,BOB64_GUI_FILENAME_CAPACITY); + if(!length||length>=BOB64_GUI_FILENAME_CAPACITY)return -1; + } + for(usize i=0;i='a'&&value<='z')||(value>='A'&&value<='Z')|| + (value>='0'&&value<='9')||value=='.'||value=='_'||value=='-'))return -1; + } + gui_copy(filename,requested,length); + result=bob64_app_read_file(filename,length,editor.Text,BOB64_EDITOR_CAPACITY); + if(result==-2) { + bob64_editor_init(&editor,0,0); + gui_copy(editor_status,"NEW FILE",sizeof("NEW FILE")); + editor_save_allowed=1; + } else if(result==-28) { + bob64_editor_init(&editor,0,0); + gui_copy(editor_status,"FILE TOO LARGE",sizeof("FILE TOO LARGE")); + editor_save_allowed=0; + } else if(result<0) { + return -1; + } else { + bob64_editor_init(&editor,editor.Text,(u32)result); + gui_copy(editor_status,"LOADED",sizeof("LOADED")); + editor_save_allowed=1; + } + return 0; +} + +static void gui_refresh_files(void) { + s64 result=bob64_app_list_files(file_entries,BOB64_SYSCALL_MAX_FILES); + if(result<0) { + file_count=0; + gui_copy(editor_status,result==-28?"TOO MANY FILES":"LIST FAILED", + result==-28?sizeof("TOO MANY FILES"):sizeof("LIST FAILED")); + return; + } + file_count=(u32)result; + if(selected_file>=file_count)selected_file=file_count?file_count-1:0; + if(file_scroll>=file_count)file_scroll=file_count?file_count-1:0; +} + +static void gui_reveal_selected_file(void) { + BOB64_WINDOW *window=bob64_wm_find(&manager,files_window); + u32 rows=window&&window->Height>58?(window->Height-58)/14:1; + if(!rows)rows=1; + if(selected_file=file_scroll+rows)file_scroll=selected_file-rows+1; +} + +static int gui_name_equal(const char *left,const char *right) { + while(*left&&*right&&*left==*right){left++;right++;} + return !*left&&!*right; +} + +static void gui_open_selected_file(void) { + s64 result; + if(selected_file>=file_count) { + gui_copy(editor_status,"NO FILE SELECTED",sizeof("NO FILE SELECTED"));return; + } + const char *name=file_entries[selected_file].Name; + if(editor.Dirty&&!editor_open_armed) { + gui_copy(editor_status,"OPEN AGAIN TO DISCARD",sizeof("OPEN AGAIN TO DISCARD")); + editor_open_armed=1;return; + } + if(gui_name_equal(name,filename)) { + gui_focus_window(editor_window); + gui_copy(editor_status,"CURRENT FILE",sizeof("CURRENT FILE")); + editor_open_armed=0;return; + } + result=bob64_app_read_file(name,gui_length(name,BOB64_GUI_FILENAME_CAPACITY), + editor.Text,BOB64_EDITOR_CAPACITY); + if(result==-28) { + gui_copy(editor_status,"FILE TOO LARGE",sizeof("FILE TOO LARGE")); + editor_save_allowed=0;return; + } + if(result<0) { + gui_copy(editor_status,"OPEN FAILED",sizeof("OPEN FAILED"));return; + } + gui_copy(filename,name,gui_length(name,BOB64_GUI_FILENAME_CAPACITY)); + bob64_editor_init(&editor,editor.Text,(u32)result); + editor_save_allowed=1;editor_open_armed=0; + gui_copy(editor_status,"LOADED",sizeof("LOADED")); + gui_focus_window(editor_window); +} + +static void gui_delete_selected_file(void) { + const char *name; + s64 result; + if(selected_file>=file_count) { + gui_copy(editor_status,"NO FILE SELECTED",sizeof("NO FILE SELECTED"));return; + } + name=file_entries[selected_file].Name; + if(gui_name_equal(name,filename)) { + file_delete_armed=0; + gui_copy(editor_status,"SAVE OR OPEN OTHER FILE",sizeof("SAVE OR OPEN OTHER FILE")); + return; + } + if(!file_delete_armed) { + file_delete_armed=1; + gui_copy(editor_status,"D AGAIN TO DELETE",sizeof("D AGAIN TO DELETE")); + return; + } + result=bob64_app_delete_file(name,gui_length(name,BOB64_GUI_FILENAME_CAPACITY)); + file_delete_armed=0; + if(result)gui_copy(editor_status,"DELETE FAILED",sizeof("DELETE FAILED")); + else {gui_refresh_files();gui_copy(editor_status,"DELETED",sizeof("DELETED"));} +} + +static void gui_draw_window(const BOB64_WINDOW *window,int focused) { + BOB64_WINDOW local=*window; + BOB64_GFX *graphics; + local.X=0;local.Y=0;window=&local; + graphics=gui_graphics_for_handle(window->Handle); + if(!graphics)return; + const char *title=(const char *)window->Context; + u32 border=focused?0x00a4c8ffu:0x006d8095u; + u32 title_bar=focused?0x00335d8cu:0x00334050u; + bob64_gfx_fill_rect(graphics,window->X,window->Y,window->Width, + window->Height,0x0009111bu); + bob64_gfx_fill_rect(graphics,window->X+2,window->Y+2,window->Width-4, + window->Height-4,0x001a2a3cu); + bob64_gfx_fill_rect(graphics,window->X,window->Y,window->Width, + BOB64_WINDOW_TITLE_BAR_HEIGHT,title_bar); + bob64_gfx_line(graphics,window->X,window->Y, + window->X+(s32)window->Width-1,window->Y,border); + bob64_gfx_line(graphics,window->X,window->Y+(s32)window->Height-1, + window->X+(s32)window->Width-1, + window->Y+(s32)window->Height-1,border); + bob64_gfx_line(graphics,window->X,window->Y,window->X, + window->Y+(s32)window->Height-1,border); + bob64_gfx_line(graphics,window->X+(s32)window->Width-1,window->Y, + window->X+(s32)window->Width-1, + window->Y+(s32)window->Height-1,border); + bob64_gfx_text(graphics,window->X+12,window->Y+8,title,0x00ffffffu,1); + if(window->Handle==editor_window) { + u32 columns=(window->Width-24)/6; + u32 rows=(window->Height-76)/10; + u32 column=0,row=0; + u32 cursor_row,cursor_column; + s32 text_x=window->X+12,text_y=window->Y+46; + int caret_visible=0; + if(columns==0)columns=1; + bob64_editor_visual_position(&editor,columns,&cursor_row,&cursor_column); + (void)cursor_column; + if(cursor_row=editor.ScrollRow+rows) + editor.ScrollRow=cursor_row-rows+1; + bob64_gfx_text(graphics,window->X+12,window->Y+30,filename, + 0x009eb3c7u,1); + for(u32 i=0;i<=editor.Length;i++) { + if(column>=columns&&(i==editor.Length||editor.Text[i]!='\n')) { + row++;column=0; + } + if(i==editor.Cursor) { + s32 caret_x=text_x+(s32)(column*6); + s32 caret_y=text_y+(s32)((row-editor.ScrollRow)*10); + if(row>=editor.ScrollRow&&row=editor.ScrollRow&&row=editor.ScrollRow&&rowX+8, + window->Y+(s32)window->Height-22, + window->X+(s32)window->Width-8, + window->Y+(s32)window->Height-22,0x0044576au); + bob64_gfx_text(graphics,window->X+12, + window->Y+(s32)window->Height-16,editor_status,0x008fc8ffu,1); + bob64_gfx_text(graphics,window->X+(s32)window->Width/2, + window->Y+(s32)window->Height-16,"CTRL S SAVE",0x009eb3c7u,1); + } else if(window->Handle==files_window) { + u32 rows=window->Height>58?(window->Height-58)/14:0; + bob64_gfx_text(graphics,window->X+10,window->Y+31, + "UP DOWN OPEN R REFRESH",0x009eb3c7u,1); + bob64_gfx_text(graphics,window->X+10,window->Y+41, + "D TWICE DELETE",0x009eb3c7u,1); + bob64_gfx_text(graphics,window->X+10,window->Y+49,editor_status, + 0x008fc8ffu,1); + for(u32 row=0;rowY+56+(s32)(row*14); + if(index==selected_file) + bob64_gfx_fill_rect(graphics,window->X+6,y-2, + window->Width-12,12,0x00335d8cu); + bob64_gfx_text(graphics,window->X+10,y, + file_entries[index].Name,index==selected_file? + 0x00ffffffu:0x00dbe8f4u,1); + } + if(!file_count)bob64_gfx_text(graphics,window->X+10,window->Y+60, + "NO FILES",0x008fc8ffu,1); + } else if(window->Handle==manager.Focused) { + bob64_gfx_text(graphics,window->X+14,window->Y+46, + "BOB64 DESKTOP",0x007ed6ffu,1); + bob64_gfx_text(graphics,window->X+14,window->Y+66, + "RUN DESKTOP B64E FILE",0x00dbe8f4u,1); + bob64_gfx_text(graphics,window->X+14,window->Y+84, + "TAB SWITCH WINDOWS",0x00dbe8f4u,1); + bob64_gfx_text(graphics,window->X+14,window->Y+102, + "ESC RETURN TO SHELL",0x00dbe8f4u,1); + bob64_gfx_text(graphics,window->X+14,window->Y+120, + "N NEW X CLOSE OTHER",0x00dbe8f4u,1); + } else { + bob64_gfx_text(graphics,window->X+14,window->Y+46, + "DRAG WINDOW TITLE",0x00dbe8f4u,1); + } +} + +static int gui_draw(s32 cursor_x,s32 cursor_y) { + for(u32 i=0;iFlags&BOB64_WINDOW_VISIBLE))continue; + surface=gui_graphics_for_handle(window->Handle); + if(!surface)continue; + bob64_gfx_fill_rect(surface,0,0,surface->Width,surface->Height, + 0x000d1723u); + for(u32 y=0;yHeight;y+=4) + bob64_gfx_line(surface,0,(s32)y,(s32)surface->Width-1,(s32)y, + 0x00132130u); + gui_draw_window(window,window->Handle==manager.Focused); + if(cursor_x>=window->X&&cursor_y>=window->Y&& + (u32)(cursor_x-window->X)Width&& + (u32)(cursor_y-window->Y)Height) { + s32 x=cursor_x-window->X,y=cursor_y-window->Y; + bob64_gfx_line(surface,x-5,y,x+5,y,0x00000000u); + bob64_gfx_line(surface,x,y-5,x,y+5,0x00000000u); + bob64_gfx_line(surface,x-3,y,x+3,y,0x00ffffffu); + bob64_gfx_line(surface,x,y-3,x,y+3,0x00ffffffu); + } + if(bob64_app_window_present(window->Handle,surface->Pixels, + surface->Width,surface->Height)!=(s64)((u64)surface->Width*surface->Height)) + return -1; + } + return 0; +} + +static void gui_save_editor(void) { + if(!editor_save_allowed) { + gui_copy(editor_status,"FILE TOO LARGE",sizeof("FILE TOO LARGE")); + return; + } + s64 result=bob64_app_write_file(filename,gui_length(filename, + BOB64_GUI_FILENAME_CAPACITY),editor.Text,editor.Length); + if(result==(s64)editor.Length) { + editor.Dirty=0;gui_copy(editor_status,"SAVED",sizeof("SAVED")); + } else gui_copy(editor_status,"SAVE FAILED",sizeof("SAVE FAILED")); +} + +static void gui_editor_place_cursor(u32 target_row,u32 target_column,u32 columns) { + u32 row=0,column=0; + if(!columns)columns=1; + target_row+=editor.ScrollRow; + for(u32 i=0;i<=editor.Length;i++) { + if(column>=columns&&(i==editor.Length||editor.Text[i]!='\n')) { + row++;column=0; + } + if(row==target_row&&column>=target_column) { + editor.Cursor=i;return; + } + if(i==editor.Length)break; + if(editor.Text[i]=='\n') { + if(row==target_row){editor.Cursor=i;return;} + row++;column=0;continue; + } + column++; + } + editor.Cursor=editor.Length; +} + +static void gui_focus_next(void) { + if(!manager.Count)return; + u32 start=0; + for(u32 i=0;iFlags&BOB64_WINDOW_VISIBLE)) { + gui_focus_window(handle);return; + } + } +} + +static void gui_key(const BOB64_EVENT *event) { + if(event->Type!=BOB64_EVENT_KEY_DOWN)return; + if(event->Character=='\t')gui_focus_next(); + else if(manager.Focused==files_window) { + if(event->Key==(BOB64_EVENT_KEY_EXTENDED|0x48)) { + if(selected_file)selected_file--; + gui_reveal_selected_file(); + file_delete_armed=editor_open_armed=0; + } else if(event->Key==(BOB64_EVENT_KEY_EXTENDED|0x50)) { + if(selected_file+1Character=='r'||event->Character=='R') { + gui_refresh_files();file_delete_armed=editor_open_armed=0; + } else if(event->Character=='o'||event->Character=='O'|| + event->Character=='\n')gui_open_selected_file(); + else if(event->Character=='d'||event->Character=='D')gui_delete_selected_file(); + else file_delete_armed=editor_open_armed=0; + } + else if(event->Character=='n'&&manager.CountCharacter=='x'&&manager.Count>1&&manager.Focused!=editor_window) { + if(gui_destroy_window(manager.Focused)) + gui_copy(editor_status,"WINDOW CLOSE FAILED",sizeof("WINDOW CLOSE FAILED")); + } + else if(manager.Focused==editor_window) { + if((event->Modifiers&BOB64_EVENT_MOD_CONTROL)&& + (event->Character=='s'||event->Character=='S'))gui_save_editor(); + else bob64_editor_handle_key(&editor,event); + } +} + +s64 bob64_app_main(const BOB64_APP_STARTUP *startup) { + BOB64_EVENT event; + BOB64_EVENT routed; + BOB64_EVENT screen_event; + s32 cursor_x,cursor_y; + if(!startup||startup->AbiVersion!=BOB64_APP_ABI_VERSION|| + bob64_app_query_abi()!=BOB64_SYSCALL_ABI_VERSION)return -1; + if(bob64_app_write("bob!",4)!=4)return -3; + if(bob64_app_get_display(&screen_width,&screen_height))return -6; + if(screen_width<480||screen_height<300||screen_width>BOB64_GUI_MAX_WIDTH|| + screen_height>BOB64_GUI_MAX_HEIGHT)return -7; + if(bob64_wm_init(&manager,windows,BOB64_GUI_MAX_WINDOWS,order, + screen_width,screen_height))return -8; + if(gui_load_file(startup))return -9; + gui_refresh_files(); + cursor_x=(s32)(screen_width/2);cursor_y=(s32)(screen_height/2); + if(!gui_create_window(8,24,screen_width/3,screen_height-32,titles[0])|| + !gui_create_window((s32)(screen_width/3+16),24, + screen_width-screen_width/3-24,screen_height-32,titles[1]))return -2; + files_window=manager.ZOrder[0]; + editor_window=manager.Focused; + for(;;) { + if(gui_draw(cursor_x,cursor_y))return -4; + if(bob64_app_wait_event(&event))return -5; + if(event.Type==BOB64_EVENT_KEY_DOWN&&event.Character==0x1b) { + if(editor.Dirty&&!editor_exit_armed) { + gui_copy(editor_status,"ESC AGAIN TO QUIT",sizeof("ESC AGAIN TO QUIT")); + editor_exit_armed=1;continue; + } + break; + } + if(event.Type==BOB64_EVENT_KEY_DOWN)editor_exit_armed=0; + if(event.Type==BOB64_EVENT_MOUSE_MOVE||event.Type==BOB64_EVENT_MOUSE_BUTTON|| + event.Type==BOB64_EVENT_MOUSE_WHEEL) + cursor_x=event.ScreenX,cursor_y=event.ScreenY; + screen_event=event;screen_event.X=event.ScreenX;screen_event.Y=event.ScreenY; + bob64_wm_dispatch(&manager,&screen_event,&routed); + if(event.Type==BOB64_EVENT_MOUSE_BUTTON&&(event.Buttons&1u)&& + manager.Focused==files_window&&routed.X>=8&&routed.Y>=56) { + u32 row=(u32)(routed.Y-56)/14; + if(file_scroll+row=12&&routed.Y>=46) { + BOB64_WINDOW *window=bob64_wm_find(&manager,editor_window); + if(window)gui_editor_place_cursor((u32)(routed.Y-46)/10, + (u32)(routed.X-12)/6,(window->Width-24)/6); + } + gui_key(&event); + if(editor.Dirty)gui_copy(editor_status,"UNSAVED",sizeof("UNSAVED")); + } + return 0; +} diff --git a/apps/bob64_smoke.c b/apps/bob64_smoke.c new file mode 100644 index 0000000..9d3439b --- /dev/null +++ b/apps/bob64_smoke.c @@ -0,0 +1,33 @@ +#include "../bob64/app.h" +#include "../bob64/libc.h" + +s64 bob64_app_main(const BOB64_APP_STARTUP *startup) { + static const char message[]="bob!"; + static const char file_name[]="bob-app.txt"; + static const char stream_name[]="bob-stream.txt"; + static const char file_data[]="written by a C app"; + char file_copy[32]; + if(!startup||startup->AbiVersion!=BOB64_APP_ABI_VERSION)return -1; + if(bob64_app_query_abi()!=BOB64_SYSCALL_ABI_VERSION)return -2; + u64 ticks_before=bob64_app_ticks(); + if(bob64_app_write(message,sizeof(message)-1)!=(s64)(sizeof(message)-1))return -3; + if(bob64_app_write_file(file_name,sizeof(file_name)-1,file_data, + sizeof(file_data)-1)!=(s64)(sizeof(file_data)-1))return -4; + s64 copied=bob64_app_read_file(file_name,sizeof(file_name)-1,file_copy, + sizeof(file_copy)); + if(copied!=(s64)(sizeof(file_data)-1))return -5; + if(bob64_memcmp(file_copy,file_data,sizeof(file_data)-1))return -6; + s64 handle=bob64_app_file_open(stream_name,sizeof(stream_name)-1, + BOB64_FILE_OPEN_READ|BOB64_FILE_OPEN_WRITE|BOB64_FILE_OPEN_CREATE| + BOB64_FILE_OPEN_TRUNCATE); + if(handle<=0)return -7; + if(bob64_app_file_write(handle,file_data,sizeof(file_data)-1)!= + (s64)(sizeof(file_data)-1))return -8; + if(bob64_app_file_seek(handle,0)!=0)return -9; + copied=bob64_app_file_read(handle,file_copy,sizeof(file_copy)); + if(copied!=(s64)(sizeof(file_data)-1)|| + bob64_memcmp(file_copy,file_data,sizeof(file_data)-1))return -10; + if(bob64_app_file_close(handle))return -11; + if(bob64_app_ticks()0&&text[length-1]!='\n')bob_putc('\n'); + return 0; +} diff --git a/apps/echo.c b/apps/echo.c new file mode 100644 index 0000000..4974af5 --- /dev/null +++ b/apps/echo.c @@ -0,0 +1,15 @@ +#include "bob.h" + +static void write_text(const char *text) { + while (*text) bob_putc(*text++); +} + +int main(int argc, char **argv) { + int i; + for (i = 1; i < argc; i++) { + if (i > 1) bob_putc(' '); + write_text(argv[i]); + } + bob_putc('\n'); + return 0; +} diff --git a/apps/graphics_demo.c b/apps/graphics_demo.c new file mode 100644 index 0000000..0878598 --- /dev/null +++ b/apps/graphics_demo.c @@ -0,0 +1,31 @@ +#include "bob.h" +#include "bob_gfx.h" +#include "bob_event.h" + +int main(void) { + int resolution[2]; + int event[4]; + char bitmap[8] = {'/', '-', '\\', '|', '\\', '-', '/', '|'}; + if (bob_gfx_enter()) return 1; + if (bob_gfx_resolution(resolution) != 2 || resolution[0] != 80 || resolution[1] != 25) { + bob_gfx_leave(); + return 2; + } + bob_gfx_clear(' ', 0); + bob_gfx_fill_rect(1, 1, 78, 23, '.', 1); + bob_gfx_fill_rect(2, 2, 76, 3, ' ', 4); + bob_gfx_text(4, 3, "BOB32 GRAPHICS DEMO", 15); + bob_gfx_line(3, 7, 76, 7, '=', 14); + bob_gfx_pixel(40, 16, '*', 10); + bob_gfx_fill_rect(8, 10, 12, 5, '#', 2); + bob_gfx_blit(28, 10, 4, 2, bitmap, 12); + bob_gfx_text(4, 19, "Press any key to return to the shell", 15); + if (bob_gfx_present()) { bob_gfx_leave(); return 3; } + if (bob_event_wait(event) != 1 || event[0] != BOB_EVENT_CHAR || event[1] != 'x') { + bob_gfx_leave(); + return 4; + } + if (bob_gfx_leave()) return 5; + bob_puts("bob!"); + return 0; +} diff --git a/apps/gui_demo.c b/apps/gui_demo.c new file mode 100644 index 0000000..b3200be --- /dev/null +++ b/apps/gui_demo.c @@ -0,0 +1,462 @@ +#include "bob.h" +#include "bob_gfx.h" +#include "bob_font.h" +#include "bob_event.h" +#include "bob_gui.h" +#include "bob_fs.h" +#include "bob_process.h" +#include "bob_string.h" + +static void gui_select_file(int row,const int *slots,int count,int *selected, + char *status,char *preview,int *preview_length,int *preview_scroll) { + int size,kind;char name[24],size_text[12]; + if(row<0||row>=count)return; + *selected=row; + kind=bob_file_list(slots[row],name,24,&size); + bob_format_int(size,size_text,12); + bob_strcpy(status,name);bob_strcat(status," ");bob_strcat(status,size_text); + preview[0]=0;*preview_length=-1;*preview_scroll=0; + if(kind==0)*preview_length=bob_file_read(name,preview,512); +} + +static int gui_preview_offset(const char *preview,int length,int lines) { + int position=0,column; + while(lines>0&&position=count)return -1; + kind=bob_file_list(slots[row],name,24,&size); + if(kind!=0)return -1; + return bob_file_delete(name); +} + +static void gui_wm_sync_rects(int *rects,const int *managed) { + for(int id=0;id<2;id++)for(int i=0;i<4;i++) + rects[id*4+i]=managed[id*BOB_WM_WINDOW_WORDS+i]; +} + +static void gui_place_editor_widgets(int *windows,int *name_field,int *text_area,int *button) { + int *rect=windows; + name_field[0]=rect[0]+2;name_field[1]=rect[1]+5; + text_area[0]=rect[0]+2;text_area[1]=rect[1]+9; + button[0]=rect[0]+3;button[1]=rect[1]+16; +} + +static int gui_open_selected_text(int row,const int *slots,int count,char *name, + char *filename,char *text,int *text_state,const int *text_area, + int *wm_state,int *wm_windows,int *wm_order,char *status) { + int size,kind,length; + if(row<0||row>=count){bob_strcpy(status,"Select a text file.");return 0;} + kind=bob_file_list(slots[row],name,24,&size); + if(kind!=BOB_FILE_KIND_TEXT){bob_strcpy(status,"Text files only.");return 0;} + length=bob_file_read(name,text,512); + if(length<0){bob_strcpy(status,"Could not read file.");return 0;} + bob_strcpy(filename,name); + bob_gui_text_area_init(text,text_state,512); + bob_gui_text_area_reveal(text,text_state,text_area); + text_state[0]=1;bob_wm_focus(wm_state,wm_windows,wm_order,0); + bob_strcpy(status,"Editing selected file."); + return 1; +} + +static void gui_launch_app(int row,const char *names,int count,char *message) { + char number[12]; + int child_status=-1,status; + if(row<0||row>=count){bob_strcpy(message,"No app selected.");return;} + status=bob_app_run(names+row*24,"",&child_status); + if(status==-1)bob_strcpy(message,"App not found."); + else if(status==-2)bob_strcpy(message,"Not a native app."); + else if(status==-4)bob_strcpy(message,"Invalid app image."); + else if(status==-5)bob_strcpy(message,"Not enough memory."); + else if(status<0)bob_strcpy(message,"App launch failed."); + else { + bob_strcpy(message,"App exit ");bob_format_int(child_status,number,12); + bob_strcat(message,number); + } +} + +int main(void) { + int event[4]; + int mouse_x=-1; + int mouse_y=-1; + int wm_state[10]; + int wm_windows[14]; + int wm_order[2]; + int routed_event[4]; + int target_window=-1; + int redraw_full=0; + int overlay_was_open=0; + int draw_id=-1; + int windows[8]; + int button[4]={6,19,31,3}; + int button_state[2]={0,0}; + int delete_yes[4]={43,17,13,3}; + int delete_no[4]={59,17,13,3}; + int delete_yes_state[2]={0,0}; + int delete_no_state[2]={0,0}; + int name_field[4]={5,8,33,3}; + int text_area[4]={5,12,33,7}; + int name_state[3]; + int text_state[4]; + int length_b=0; + int file_slots[8]; + char app_names[192]; + int app_count=0; + int app_selected=0; + int launcher_open=0; + int help_open=0; + int help_close[4]={32,18,16,3}; + int help_close_state[2]={0,0}; + int launch_button[4]={42,18,16,3}; + int close_button[4]={22,18,14,3}; + int launch_button_state[2]={0,0}; + int close_button_state[2]={0,0}; + int file_count=0; + int selected_file=-1; + int selection_initialized=0; + int file_scroll=0; + int delete_confirm=0; + int menu_open=0; + int menu_rect[4]={43,7,30,5}; + int menu_state[2]={0,-1}; + int file_size; + int file_kind; + int preview_length=-1; + int preview_scroll=0; + int preview_row,preview_column,preview_position; + char preview[512]; + char preview_line[35]; + char file_name[24]; + char file_name_text[24]="new.txt"; + char file_text[512]="bob!"; + char message_b[32]=""; + char menu_items[72]; + int running=1; + bob_strcpy(message_b,"N/P select; E edit; X delete"); + bob_strcpy(menu_items,"Open selected text"); + bob_strcpy(menu_items+24,"Delete selected"); + bob_strcpy(menu_items+48,"Close menu"); + bob_gui_text_field_init(file_name_text,name_state,24); + bob_gui_text_area_init(file_text,text_state,512); + name_state[0]=1; + if(bob_wm_init(wm_state,wm_windows,wm_order,2,80,25))return 1; + if(bob_wm_create(wm_state,wm_windows,wm_order,3,3,37,20)!=0|| + bob_wm_create(wm_state,wm_windows,wm_order,41,3,37,20)!=1)return 1; + bob_wm_focus(wm_state,wm_windows,wm_order,0); + if(bob_gfx_enter())return 1; + while(running) { + gui_wm_sync_rects(windows,wm_windows); + gui_place_editor_widgets(windows,name_field,text_area,button); + bob_gui_menu_place(menu_rect,windows[4]+2,windows[5]+4,30,3,80,25); + file_count=0; + app_count=0; + for(int i=0;i<8;i++) { + file_kind=bob_file_list(i,file_name,24,&file_size); + if(file_kind>=0)file_slots[file_count++]=i; + if(file_kind==BOB_FILE_KIND_NATIVE_APP) { + bob_strcpy(app_names+app_count*24,file_name);app_count++; + } + } + if(app_selected>=app_count)app_selected=app_count?app_count-1:0; + if(!selection_initialized&&file_count>0) { + gui_select_file(0,file_slots,file_count,&selected_file,message_b,preview,&preview_length,&preview_scroll); + selection_initialized=1; + } + if(selected_file>=file_count) { + selected_file=-1;preview_length=-1;preview_scroll=0;delete_confirm=0; + bob_strcpy(message_b,"Selection changed."); + } + if(file_scroll>file_count-6)file_scroll=file_count>6?file_count-6:0; + if(selected_file>=0) { + if(selected_file=file_scroll+6)file_scroll=selected_file-5; + } + if(menu_open||launcher_open||help_open||overlay_was_open)wm_state[8]=1; + redraw_full=wm_state[8]; + bob_wm_begin_draw(wm_state,wm_windows,wm_order); + if(redraw_full) { + bob_gfx_clear('.',1); + bob_gfx_text(2,0,"BOB32 DESKTOP ?: HELP TAB: FOCUS CTRL+S: SAVE ESC: EXIT",15); + } + while((draw_id=bob_wm_next_dirty(wm_state,wm_windows,wm_order))>=0) { + int id=draw_id;int *rect=windows+id*4; + if(id==0)bob_gui_window(rect[0],rect[1],rect[2],rect[3],"Text editor", + "E opens text. Tab changes focus.","Ctrl+S saves; Enter starts a new line.",wm_state[2]==0); + else { + bob_gui_window(rect[0],rect[1],rect[2],rect[3],"Window B","File menu: M or click File",message_b,wm_state[2]==1); + for(int row=0;row<6&&file_scroll+row ":" ",wm_state[2]==1?15:8); + bob_gfx_text(rect[0]+4,rect[1]+4+row,file_name,wm_state[2]==1?15:7); + } + if(delete_confirm) { + bob_gfx_text(rect[0]+2,rect[1]+11,"Delete selected text file?",wm_state[2]==1?14:8); + delete_yes[0]=rect[0]+2;delete_yes[1]=rect[1]+14; + delete_no[0]=rect[0]+19;delete_no[1]=rect[1]+14; + bob_gui_button_draw(delete_yes[0],delete_yes[1],delete_yes[2],delete_yes[3],"Yes, delete",delete_yes_state[0],delete_yes_state[1]); + bob_gui_button_draw(delete_no[0],delete_no[1],delete_no[2],delete_no[3],"Cancel",delete_no_state[0],delete_no_state[1]); + } else { + bob_gfx_text(rect[0]+2,rect[1]+11,"Preview:",wm_state[2]==1?14:8); + if(preview_length<0)bob_gfx_text(rect[0]+2,rect[1]+12,"No text preview.",wm_state[2]==1?7:8); + preview_position=gui_preview_offset(preview,preview_length,preview_scroll); + for(preview_row=0;preview_row<6&&preview_position=0&&selected_file=21&&event[2]<59&&row>=0&&row0)app_selected--; + else if(event[1]==257&&app_selected+10)app_selected--; + else if(event[1]=='r'){gui_launch_app(app_selected,app_names,app_count,message_b);launcher_open=0;} + } + continue; + } + if(event[0]==BOB_EVENT_CHAR&&event[1]==27){running=0;break;} + target_window=bob_wm_dispatch(wm_state,wm_windows,wm_order,event,routed_event); + if(target_window<0)continue; + for(int i=0;i<4;i++)event[i]=routed_event[i]; + gui_wm_sync_rects(windows,wm_windows); + gui_place_editor_widgets(windows,name_field,text_area,button); + bob_wm_invalidate(wm_state,wm_windows,wm_order,target_window); + if(event[0]==BOB_EVENT_MOUSE_MOVE||event[0]==BOB_EVENT_MOUSE_BUTTON_DOWN|| + event[0]==BOB_EVENT_MOUSE_BUTTON_UP||event[0]==BOB_EVENT_MOUSE_WHEEL) { + event[2]+=windows[target_window*4];event[3]+=windows[target_window*4+1]; + } + if(event[0]==BOB_EVENT_MOUSE_MOVE) { + mouse_x=event[2];mouse_y=event[3]; + if(wm_state[2]==0)bob_gui_button_event(button,button_state,event); + else button_state[0]=0; + if(wm_state[2]==1&&delete_confirm) { + bob_gui_button_event(delete_yes,delete_yes_state,event); + bob_gui_button_event(delete_no,delete_no_state,event); + } else {delete_yes_state[0]=0;delete_no_state[0]=0;} + continue; + } + if(event[0]==BOB_EVENT_MOUSE_WHEEL) { + mouse_x=event[2];mouse_y=event[3]; + if(wm_state[2]==0&&bob_gui_window_hit(mouse_x,mouse_y,text_area)) { + name_state[0]=0;bob_wm_focus(wm_state,wm_windows,wm_order,0); + bob_gui_text_area_event(text_area,file_text,text_state,512,event); + } else if(wm_state[2]==1&&bob_gui_window_hit(mouse_x,mouse_y,windows+4)) { + if(mouse_y>=windows[5]+4&&mouse_y0?selected_file-1:selected_file+1; + if(row>=0&&row=windows[5]+11&&mouse_y0&&preview_scroll>0)preview_scroll--; + else if(event[1]<0&&gui_preview_offset(preview,preview_length,preview_scroll+1)=windows[4]+2&&mouse_x=windows[5]+4&&mouse_y=0)gui_select_file(selected_file,file_slots,file_count,&selected_file,message_b,preview,&preview_length,&preview_scroll); + } + if(wm_state[2]==0&&bob_gui_button_event(button,button_state,event)) { + if(bob_file_write(file_name_text,file_text,bob_strlen(file_text))==0) { + bob_strcpy(message_b,"Saved file.");selected_file=-1;selection_initialized=0; + } else bob_strcpy(message_b,"Save failed; check name."); + } + continue; + } + if(event[0]==BOB_EVENT_KEY_DOWN) { + if(wm_state[2]==0) { + if(name_state[0])bob_gui_text_field_event(name_field,file_name_text,name_state,24,event); + else if(text_state[0])bob_gui_text_area_event(text_area,file_text,text_state,512,event); + } + else if(event[1]==256&&preview_scroll>0)preview_scroll--; + else if(event[1]==257&&gui_preview_offset(preview,preview_length,preview_scroll+1)=0)gui_select_file(selected_file,file_slots,file_count,&selected_file,message_b,preview,&preview_length,&preview_scroll); + bob_strcpy(message_b,"Delete cancelled."); + } else if(wm_state[2]==1&&delete_confirm) { + } + else if(wm_state[2]==1&&event[1]=='n'&&selected_file+10) { + gui_select_file(selected_file-1,file_slots,file_count,&selected_file,message_b,preview,&preview_length,&preview_scroll); + } else if(wm_state[2]==1&&event[1]=='x'&&selected_file>=0) { + int selected_size,selected_kind; + selected_kind=bob_file_list(file_slots[selected_file],file_name,24,&selected_size); + if(selected_kind==0){delete_confirm=1;delete_yes_state[0]=0;delete_yes_state[1]=0;delete_no_state[0]=0;delete_no_state[1]=0;bob_strcpy(message_b,"Delete? Y/N");} + else bob_strcpy(message_b,"Text files only."); + } else if(wm_state[2]==1&&event[1]=='u'&&preview_scroll>0)preview_scroll--; + else if(wm_state[2]==1&&event[1]=='d'&&gui_preview_offset(preview,preview_length,preview_scroll+1)0)message_b[--length_b]=0; + } else if(event[1]>=32&&event[1]<127) { + if(wm_state[2]==1&&length_b<30) { + message_b[length_b++]=event[1];message_b[length_b]=0; + } + } + } + if(bob_gfx_leave())return 2; + bob_puts("bob!"); + return 0; +} diff --git a/apps/launcher.c b/apps/launcher.c new file mode 100644 index 0000000..2b20815 --- /dev/null +++ b/apps/launcher.c @@ -0,0 +1,51 @@ +#include "bob.h" +#include "bob_fs.h" +#include "bob_process.h" +#include "bob_string.h" + +static int append(char *buffer,int *length,char value) { + if(*length>=126)return 0; + buffer[(*length)++]=value;buffer[*length]=0;return 1; +} + +static void print_number(int value) { + char digits[12];int count=0; + if(value<0){bob_putc('-');value=-value;} + do {digits[count++]=(char)('0'+value%10);value/=10;} while(value&&count<11); + while(count)bob_putc(digits[--count]); + bob_putc('\n'); +} + +int main(int argc,char **argv) { + int i,size,kind,length=0,status,child_status=-1; + char name[24],arguments[128]; + arguments[0]=0; + if(argc<2) { + bob_puts("Native apps:"); + for(i=0;i<8;i++) { + kind=bob_file_list(i,name,24,&size); + if(kind==3){bob_puts(name);bob_putc('\n');} + } + bob_puts("Usage: run launcher APP [ARG ...]"); + return 0; + } + for(i=2;i2&&!append(arguments,&length,' '))return 1; + if(!append(arguments,&length,'"'))return 1; + for(j=0;argv[i][j];j++) { + if((argv[i][j]=='"'||argv[i][j]=='\\')&&!append(arguments,&length,'\\'))return 1; + if(!append(arguments,&length,argv[i][j]))return 1; + } + if(!append(arguments,&length,'"'))return 1; + } + status=bob_app_run(argv[1],arguments,&child_status); + if(status==-1)bob_puts("App not found."); + else if(status==-2)bob_puts("File is not a native bob32 app."); + else if(status==-4)bob_puts("Invalid app or arguments."); + else if(status==-5)bob_puts("Not enough emulator memory to launch app."); + else if(status==-3)bob_puts("App timed out."); + else if(status<-5)bob_puts("App could not be launched."); + else {bob_puts("Child exit:");print_number(child_status);} + return status<0?1:child_status; +} diff --git a/apps/ls.c b/apps/ls.c new file mode 100644 index 0000000..02d0bf4 --- /dev/null +++ b/apps/ls.c @@ -0,0 +1,29 @@ +#include "bob.h" +#include "bob_fs.h" +#include "bob_string.h" + +static void write_text(const char *text) { + while (*text) bob_putc(*text++); +} + +int main(void) { + char name[24]; + char number[12]; + int size; + int kind; + int i; + for (i = 0; i < 8; i++) { + kind = bob_file_list(i, name, 24, &size); + if (kind < 0) continue; + write_text(name); + bob_putc(' '); + bob_format_int(size, number, 12); + write_text(number); + bob_putc(' '); + if (kind == 0) write_text("text"); + else if (kind == 3) write_text("native app"); + else write_text("program"); + bob_putc('\n'); + } + return 0; +} diff --git a/apps/notes.c b/apps/notes.c new file mode 100644 index 0000000..e55c0ad --- /dev/null +++ b/apps/notes.c @@ -0,0 +1,103 @@ +#include "bob.h" +#include "bob_fs.h" + +static int same_text(const char *left,const char *right) { + int i=0;while(left[i]&&left[i]==right[i])i++; + return left[i]==right[i]; +} + +/* 1=text note, 0=missing, -1=name belongs to a non-text file. */ +static int note_kind(const char *wanted) { + int kind=bob_file_kind(wanted); + if(kind<0)return 0; + return kind==BOB_FILE_KIND_TEXT?1:-1; +} + +static int join_arguments(char *text,int *length,int argc,char **argv,int start) { + *length=0; + for(int i=start;istart) { + if(*length>=511)return 0; + text[(*length)++]=' '; + } + for(int j=0;argv[i][j];j++) { + if(*length>=511)return 0; + text[(*length)++]=argv[i][j]; + } + } + text[*length]=0; + return 1; +} + +int main(int argc, char **argv) { + char text[512]; + int length; + int i; + if (argc < 2) { + bob_puts("Usage: notes show NAME | put/edit NAME [TEXT] | add NAME [TEXT] | delete NAME"); + return 1; + } + if (same_text(argv[1], "show") && argc == 3) { + if(note_kind(argv[2])<0){bob_puts("Not a text note.");return 1;} + length = bob_file_read(argv[2], text, 512); + if (length < 0) { bob_puts("Note not found."); return 1; } + for (i = 0; i < length; i++) bob_putc(text[i]); + bob_putc('\n'); + return 0; + } + if ((same_text(argv[1], "put")||same_text(argv[1], "edit")) && argc >= 3) { + if(note_kind(argv[2])<0){bob_puts("Not a text note.");return 1;} + if (argc == 3) { + bob_puts("Note text:"); + bob_gets(text, 512); + length=0;while(text[length])length++; + } else if(!join_arguments(text,&length,argc,argv,3)) { + bob_puts("Note is too long (511 characters maximum).");return 1; + } + if (bob_file_write(argv[2], text, length)) { bob_puts("Cannot save note."); return 1; } + bob_puts("Saved."); + return 0; + } + if (same_text(argv[1], "add") && argc >= 3) { + int kind=note_kind(argv[2]); + if(kind<0){bob_puts("Not a text note.");return 1;} + if(kind) { + length=bob_file_read(argv[2],text,512); + if(length<0){bob_puts("Cannot read note.");return 1;} + } else {length=0;text[0]=0;} + if(argc==3) { + if(length&&text[length-1]!='\n') { + if(length>=511){bob_puts("Note is too long (511 characters maximum).");return 1;} + text[length++]='\n'; + } + bob_puts("Add text:");bob_gets(text+length,512-length); + while(text[length])length++; + } else { + if(length&&text[length-1]!='\n') { + if(length>=511){bob_puts("Note is too long (511 characters maximum).");return 1;} + text[length++]='\n'; + } + for(i=3;i3) { + if(length>=511){bob_puts("Note is too long (511 characters maximum).");return 1;} + text[length++]=' '; + } + for(int j=0;argv[i][j];j++) { + if(length>=511){bob_puts("Note is too long (511 characters maximum).");return 1;} + text[length++]=argv[i][j]; + } + } + text[length]=0; + } + if(bob_file_write(argv[2],text,length)){bob_puts("Cannot save note.");return 1;} + bob_puts("Saved.");return 0; + } + if (same_text(argv[1], "delete") && argc == 3) { + if(note_kind(argv[2])!=1){bob_puts("Not a text note.");return 1;} + if (bob_file_delete(argv[2])) { bob_puts("Note not found."); return 1; } + bob_puts("Deleted."); + return 0; + } + bob_puts("Usage: notes show NAME | put/edit NAME [TEXT] | add NAME [TEXT] | delete NAME"); + return 1; +} diff --git a/apps/sysinfo.c b/apps/sysinfo.c new file mode 100644 index 0000000..54db1fc --- /dev/null +++ b/apps/sysinfo.c @@ -0,0 +1,50 @@ +#include "bob.h" +#include "bob_fs.h" +#include "bob_system.h" +#include "bob_string.h" + +static void write_text(const char *text) { + while (*text) bob_putc(*text++); +} + +static void show_value(const char *label, int value) { + char number[12]; + write_text(label); + bob_format_int(value, number, 12); + write_text(number); + bob_putc('\n'); +} + +int main(void) { + int info[6]; + int capabilities[5]; + if (bob_system_info(info, 6) != 6 || info[0] != BOB_FS_API_VERSION) { + bob_puts("System information service unavailable."); + return 1; + } + if (bob_system_capabilities(capabilities, 4) != -1) { + bob_puts("System capability validation failed."); + return 2; + } + if (bob_system_capabilities(capabilities, 5) != 5 || + capabilities[0] != BOB_SYSTEM_API_VERSION) { + bob_puts("System capabilities unavailable."); + return 3; + } + bob_puts("bob32 system information"); + show_value("System API version: ", capabilities[0]); + bob_puts((capabilities[1] & BOB_SYSTEM_DEVICE_CELL_FRAMEBUFFER) ? + "Cell framebuffer: available" : "Cell framebuffer: unavailable"); + show_value("Display width (cells): ", capabilities[2]); + show_value("Display height (cells): ", capabilities[3]); + bob_puts((capabilities[4] & BOB_SYSTEM_INPUT_KEYBOARD) ? + "Keyboard input: available" : "Keyboard input: unavailable"); + bob_puts((capabilities[4] & BOB_SYSTEM_INPUT_MOUSE) ? + "Mouse input: available" : "Mouse input: unavailable"); + show_value("Application address space (words): ", info[1]); + show_value("Mapped application pages: ", info[2]); + show_value("Guest files: ", info[3]); + show_value("Filesystem words used: ", info[4]); + show_value("Filesystem words free: ", info[5]); + return 0; +} diff --git a/bob-files.b32 b/bob-files.b32 index 376dd66ad62df99a25721e4d18de4296b5983cc0..e9166d9c1f5ed4280c39deb7c61d5a50cc68da26 100644 GIT binary patch delta 54 zcmey+#`vL)Nx;e2D43anfnk;7@A(poO6@iZNU-oG0R{4b7(^>>R%G$F-)z9*U_a4d F4FIb74rTxV delta 32 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 literal 79583 zcmeFadwf*I`S^b}*$oLKo~WeaebJzy1x!$sD63i6z(yB|f=azXAc;gFiODV(t98Tf z0>^bVwcgs=ma4V1wN+b%fVU)I0^S<%f=X4yR?iwQXuSYh_V<3~oXyR)pYQkedwsvZ z-yh}0*_nA}=9y=ndFGjCo|$tp^U_u=Q`0mjPb#HpZG`f#O#S}npD@{n9KY!h?a`bU zMz=WvFN~hEsIJ-F*wk=UQ`Hjp!m9fEhM;>vjk_sS@2;zN`)18{FKMW*nUI$^ywFBn zS*~f-t8%o*{?c`|_B%~mnx$!bwUaVNWMrJ8Eu~N~Pc%mhk0i`jmC76vNIb)$TaqqG z$iKD274Xa!2mP8)QMUryb%|R@(t%{!5UX6{aBWmB(eQB1EsSZ`w9jqSszB>-tx`q) z_kI>N57(9t#51J&gka6`Ah6x?BLqp`Wl#qEb8FiC3Ds4>DqyVwmmk4-oh17Il|l7{ zCaYlEp}^Pj9L94!&wzhr4D*CWtDNd%JDJkvEj$DMl}WkfR=IX*uZKs<-NrNEUzwC! z(A+Gbwv{<_Mq=Oo7Z&>JEPRUB@LW5Da(50cTPFCLnwu5^R%5}KsCMuFSLJFJH&C!r zvKS*x=v?=$a#IIG{+rsYA77@`)=tomk1A%A?C{5P;*K$?RLbp{Hf@GGloP+e8QJ5A zeBdy8Hn)~+OFEWlT5Y<#Kk}j97q4(u7|(hm?_>mZ??#!PK4Ystvc&I*U(k?yv8}c`r%-+<_lJ>oR z{gG2c@0XW+8HkU`qqsLRrO=^AFCf1>eoSF`Y?mJWH8r|jy)SB-P+uPVQje}wjkw|$ z4A=az_F!&#N&6-ds*-J~9`lQg!Ir$rf1aG&qP^y_{Ujwlv+q`W~A#8`==rA7#d9F2gGoUS#XI>ie`WIGC@jH52CW~GUP1HA3j;d`rFama&G$_%G z&@quVk(EQ19`1{;*(VKuSsvR~rr*&e{Exc~&>53{^MVX6tfci*sH?=nj6sokH_U@s zpHePacSV7t!&s#uX z9t(bHaiLZ8kH7*6*YVKePZYRSkT;qjE{qO<>~c!@;@SR$B!RijOX~#1@`m{Mea~xJ zVy45taGSs5olLU=+!e+%A`BPCKKkKxfw<>IN~i(sb?e86Ay=!2&-rR!g|SbDqDT5w z`bF?Of27M%5f6N|&kTXwpIGkj8~e@uWLFrzFZO{k)V(pA+U6e?XP-%GBY4`<8X=X zLyYKd2YuUkya3(@&}zvmEM9?H?^g3FIRSDJk^%aL{O_xL>S@VCzLlRm8mz7T|3rSJ zlMc9y(iSR4!~a#>2P`@n@9O09rI_FZr7t*K;VtH2-oTL?vnQ2 z!vr64a=0I2{E>a5f(*;Z@L3~Uf=O>;WF~}pOGk!7k0#ft#>2Fwd0V~_di1;6NAHX5 zbs!~u>`o7ZrTLGd&H#E?<0gkaqt3+)4$eo|7el%ENiEbvjmM{N$orro3vRmJCs2!l zT2+0huA)@I=~oOVj}_I&@==7!E2p}sqQ5WHv`vhT=#1a`vrrZbFCT8}vf>vBm1X9aXqbSIR$-K7OOM<_ZJD>bEMJH#H?jjpJ8R_RzWKqb zn+BP?VU;op2JlN+1(P>^i2(THlm2+=a4q#JWzn~;V z$QVZf$XL#&dmZHn9OxD1ErPpoz#&c#TAVkvWGTVqn4yJ;KiXD{Ou{%3wuT^a` z`H-?{6*3T^kQ(n;yFcOj86dx2{#vSF+GX@KQLt73Mn{G5nz_GXagT*H17rb;n? zYD_7RRx#Sj^!1JkV|$|V6_i@bo_|7G2(9XM1QK3Hv^`YRJAUw@FkpPW`uZ{lN{e#A z!y{(#l$@m>ViQHSlwGFuRv=#R4($XGueoAtR*Gp^}``(%33nb2VtYJ zIYpVsJ&lf{o-gq;ho&=E&e5YUQD3yL*XZyX7dnkj{VD21cLZ-3q~8U} zHG-rz;dg`Ⓢ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 mh$~ieSWWd^VBI?D@`