cleanup

diff --git a/.gitignore b/.gitignore
index 956b27b6eb3a8fde7d9d94ea4518b3701efdf4c5..ad88f04eb92b8c75dcddca8dafc8a8f6fdbe0214 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,2 @@
 **/.*.swp
 **/*.bin
 **/.*.swp
 **/*.bin

-**/*.o
-**/a.out
-prototype
-lifeboot

diff --git a/Makefile b/Makefile
index 3117265796c18d3baf2fe17548eeeb901cf99801..c3f555695f3be56fb99732dcb4a9cffe88fed592 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,20 +1,14 @@
-SRC_DIR := .
-PROGRAMS := prototype lifeboot
-CC := gcc
-CFLAGS := -Wall -Wextra -I.
+SRC := lifeboot.asm
+BIN := boot.bin
+QEMU := qemu-system-i386

 
 

-lifeboot: lifeboot.asm
-       nasm lifeboot.asm
+$(BIN): $(SRC)
+       nasm $(SRC) -f bin -o $(BIN)

 
 

-all: $(PROGRAMS)
-
-run: lifeboot
-       qemu-system-x86_64 -drive file=lifeboot,format=raw
-
-format:
-       find $(SRC_DIR) -iname '*.[hc]' | xargs clang-format -i --style=GNU
+run: $(BIN)
+       $(QEMU) -drive file=$(BIN),format=raw

 
 clean:
 
 clean:

-       rm -rf $(PROGRAMS) *.o
+       rm -f $(BIN)

 
 

-.PHONY: all run format clean
+.PHONY: run clean

diff --git a/lifeboot.asm b/lifeboot.asm
index 9b03696aa827eb2e63b7d2d3c609533fa85b1807..d4ba435081f7892280834e2b6e67274773c483c9 100644 (file)
--- a/lifeboot.asm
+++ b/lifeboot.asm
@@ -8,13 +8,13 @@ org 7c00h
 %define DEAD ' '            ; char to represent a dead cell
 %define ALIVE '.'           ; char to represent an alive cell
 %define PRINT_COLOR 07h     ; grey on black
 %define DEAD ' '            ; char to represent a dead cell
 %define ALIVE '.'           ; char to represent an alive cell
 %define PRINT_COLOR 07h     ; grey on black

-%define ITER_LIM 500        ; reset the simulation after ITER_LIM iterations
+%define ITER_LIM 500        ; reset the simulation after this # iterations

 
 ; constants -------------------------------------------------------------------
 
 %define COLS 80
 %define ROWS 25
 
 ; constants -------------------------------------------------------------------
 
 %define COLS 80
 %define ROWS 25

-%define VGAPGSZ 1000h
+%define VGAPGSZ 1000h       ; (bytes)

 
 ; memory layout ---------------------------------------------------------------
 
 
 ; memory layout ---------------------------------------------------------------
 


@@ -32,13 +32,15 @@ org 7c00h
 
 ; entry point -----------------------------------------------------------------
 
 
 ; entry point -----------------------------------------------------------------
 

+entry:
+

 ; initialize segment registers
 mov ax, VGA >> 4
 ; initialize segment registers
 mov ax, VGA >> 4

-mov es, ax
+mov es, ax                  ; es:0 -> video memory

 
 xor ax, ax
 
 xor ax, ax

-mov ds, ax
-mov ss, ax
+mov ds, ax                  ; ds = 0
+mov ss, ax                  ; ss = 0

 
 ; set stack pointers
 mov bp, ORG
 
 ; set stack pointers
 mov bp, ORG


@@ -50,19 +52,17 @@ cld
 ; disable cursor
 mov ch, 3fh                 ; cursor start and options
 mov ah, 01h                 ; set text-mode cursor shape
 ; disable cursor
 mov ch, 3fh                 ; cursor start and options
 mov ah, 01h                 ; set text-mode cursor shape

-int 10h                     ; video services
+int 10h                     ; bios video services

 
 ; initialize xss
 
 ; initialize xss

+.set_xss:
+    mov ah, 00h             ; get system time
+    int 1ah                 ; bios time services
+                            ; cx:dx = # clock ticks since midnight
+    or dx, dx
+    jz .set_xss             ; wait for something meaningful

 
 

-set_xss_seed:
-
-mov ah, 00h                 ; get
-int 1ah                     ;  system time
-
-cmp dx, 0
-je set_xss_seed             ; if seed is 0, xs wont work properly
-
-mov [xss], dx               ; cx:dx = number of clock ticks since midnight
+mov [xss], dx

 
 ; initialize currvgapg
 mov word [currvgapg], 0
 
 ; initialize currvgapg
 mov word [currvgapg], 0


@@ -72,21 +72,19 @@ mov word [currvgapg], 0
 start:
 
 call init_grid
 start:
 
 call init_grid

-mov word [iter], 1
+mov word [iter], 0

 
 

-; apply game of life's rules to determine the next state ----------------------
+.next_state:

 
 

-next_state:
+    call vsync_wait
+    call update_grid

 
 

-call vsync_wait
-call write_next_vga_page
+    call vsync_wait
+    call flip_vgapg

 
 

-call vsync_wait
-call flip_vga_page
-
-inc word [iter]
-cmp word [iter], ITER_LIM
-jle next_state
+    inc word [iter]
+    cmp word [iter], ITER_LIM
+    jl .next_state

 
 jmp start                   ; reset
 
 
 jmp start                   ; reset
 


@@ -94,23 +92,23 @@ jmp start                   ; reset
 
 ; functions -------------------------------------------------------------------
 
 
 ; functions -------------------------------------------------------------------
 

-; vsync_wait() - wait for display to enter the next VBlank cycle --------------
+; vsync_wait() - wait for display to enter the next retrace cycle -------------

 
 

-; clobbers ax, dx
+; clobbers al, dx

 
 vsync_wait:
 
 mov dx, 3dah                ; input status #1 register
 
 
 vsync_wait:
 
 mov dx, 3dah                ; input status #1 register
 

-.wait_on:
+.wait_retrace_end:

     in al, dx
     test al, 08h            ; vertical retrace bit
     in al, dx
     test al, 08h            ; vertical retrace bit

-    jnz .wait_on
+    jnz .wait_retrace_end

 
 

-.wait_off:
+.wait_retrace_start:

     in al, dx
     test al, 08h
     in al, dx
     test al, 08h

-    jz .wait_off
+    jz .wait_retrace_start

 
 ret
 
 
 ret
 


@@ -118,6 +116,7 @@ ret
 
 ; output:
 ; [xss]     = updated state
 
 ; output:
 ; [xss]     = updated state

+; bx        = [xss]

 
 ; clobbers bx, dx
 
 
 ; clobbers bx, dx
 


@@ -151,36 +150,39 @@ mov di, [currvgapg]         ; es:di -> grid start
 mov cx, COLS * ROWS         ; for each cell
 
 .write_cell:                ; do {
 mov cx, COLS * ROWS         ; for each cell
 
 .write_cell:                ; do {

-    call xs                 ;     [xss] = rand
+    call xs                 ;     bx = random value

     mov al, DEAD            ;     al = DEAD (likely)
 
     mov al, DEAD            ;     al = DEAD (likely)
 

-    test word [xss], 0b11
+    test bx, 0b11

 
 

-    jnz  .nz                ;     if ([xss] % 4 == 0)
+    jnz  .nz                ;     if (bx % 4 == 0)

     mov al, ALIVE           ;         al = ALIVE
 
 .nz:
     mov al, ALIVE           ;         al = ALIVE
 
 .nz:

-    stosw                   ;     [es:di] = ax ; di += 2
+    stosw                   ;     [es:di] = ax, di += 2

 
     loop .write_cell        ; } while (--cx)
 
 ret
 
 
     loop .write_cell        ; } while (--cx)
 
 ret
 

-; flip_vga_page() - flip active display page ----------------------------------
+; flip_vgapg() - flip active display page -------------------------------------
+
+; output:
+; [currvgapg] ^= VGAPGSZ

 
 

-; clobbers ax, dx
+; clobbers ax

 
 

-flip_vga_page:
+flip_vgapg:

 
 

-xor word [currvgapg], VGAPGSZ   ; flip currvgapg
-setnz al                        ; al = !(currvgapg == 0)
+xor word [currvgapg], VGAPGSZ

 
 

+setnz al                    ; al = !(currvgapg == 0)

 mov ah, 05h                 ; select active display page
 mov ah, 05h                 ; select active display page

-int 10h                     ; video services
+int 10h                     ; bios video services

 
 ret
 
 
 ret
 

-; alive_neighbours() ----------------------------------------------------------
+; alive_neighbours() - get number of alive adjacent cells ---------------------

 
 ; input:
 ; es:si     -> current grid
 
 ; input:
 ; es:si     -> current grid


@@ -202,7 +204,7 @@ enter 5, 0
 
 mov ax, cx                  ; ax = idx
 mov bl, COLS                ; bl = COLS
 
 mov ax, cx                  ; ax = idx
 mov bl, COLS                ; bl = COLS

-div bl                      ; al = idx / COLS ; ah = idx % COLS
+div bl                      ; al = idx / COLS, ah = idx % COLS

 
 mov [bp - 1], al            ; row = idx / COLS
 mov [bp - 2], ah            ; row = idx % COLS
 
 mov [bp - 1], al            ; row = idx / COLS
 mov [bp - 2], ah            ; row = idx % COLS


@@ -215,26 +217,26 @@ mov byte [bp - 4], -1       ; i = -1
 .j:                                 ; do {
 
         mov al, [bp - 4]
 .j:                                 ; do {
 
         mov al, [bp - 4]

-        or al, [bp - 5]
-        jz .continue                    ; if (!i && !j) continue
+        or al, [bp - 5]                 ; if (!i && !j)
+        jz .continue                    ;     continue

 
         mov al, [bp - 1]
         add al, [bp - 4]                ; al = row + i
 
 
         mov al, [bp - 1]
         add al, [bp - 4]                ; al = row + i
 

-        cmp al, 0
-        jl .continue                    ; if (row + i < 0) continue
+        cmp al, 0                       ; if (row + i < 0)
+        jl .continue                    ;     continue

 
 

-        cmp al, ROWS
-        jge .continue                   ; if (row + i >= ROWS) continue
+        cmp al, ROWS                    ; if (row + i >= ROWS)
+        jge .continue                   ;     continue

 
         mov ah, [bp - 2]
         add ah, [bp - 5]                ; ah = col + j
 
 
         mov ah, [bp - 2]
         add ah, [bp - 5]                ; ah = col + j
 

-        cmp ah, 0
-        jl .continue                    ; if (col + j < 0) continue
+        cmp ah, 0                       ; if (col + j < 0)
+        jl .continue                    ;     continue

 
 

-        cmp ah, COLS
-        jge .continue                   ; if (col + j >= COLS) continue
+        cmp ah, COLS                    ; if (col + j >= COLS)
+        jge .continue                   ;     continue

 
         movzx bx, ah                    ; bx = col + j
 
 
         movzx bx, ah                    ; bx = col + j
 


@@ -246,8 +248,8 @@ mov byte [bp - 4], -1       ; i = -1
 
         mov dx, [es:si + bx]            ; dl = cell state
 
 
         mov dx, [es:si + bx]            ; dl = cell state
 

-        cmp dl, ALIVE                   ; if (!ALIVE) continue
-        jne .continue
+        cmp dl, ALIVE                   ; if (!ALIVE)
+        jne .continue                   ;     continue

 
         inc byte [bp - 3]               ; neighbours++
 
 
         inc byte [bp - 3]               ; neighbours++
 


@@ -265,7 +267,7 @@ movzx ax, byte [bp - 3]     ; ax = # alive neighbours
 leave
 ret
 
 leave
 ret
 

-; write_next_cell_state() -----------------------------------------------------
+; update_cell() - write next cell state ---------------------------------------

 
 ; input:
 ; es:si     -> current grid
 
 ; input:
 ; es:si     -> current grid


@@ -277,7 +279,7 @@ ret
 
 ; clobbers ax, bx, dx
 
 
 ; clobbers ax, bx, dx
 

-write_next_cell_state:
+update_cell:

 
 call alive_neighbours       ; ax = # alive neighbours
 
 
 call alive_neighbours       ; ax = # alive neighbours
 


@@ -314,25 +316,25 @@ mov [es:di + bx], dx
 
 ret
 
 
 ret
 

-; write_next_vga_page() -------------------------------------------------------
+; update_grid() - write next grid (inactive vga page) -------------------------

 
 ; clobbers di, si, ax, bx, cx, dx
 
 
 ; clobbers di, si, ax, bx, cx, dx
 

-write_next_vga_page:
+update_grid:

 
 mov si, [currvgapg]         ; es:si -> current page
 
 mov di, VGAPGSZ
 xor di, si                  ; es:di -> next page
 
 
 mov si, [currvgapg]         ; es:si -> current page
 
 mov di, VGAPGSZ
 xor di, si                  ; es:di -> next page
 

-xor cx, cx                  ; i = 0
+mov cx, COLS * ROWS - 1     ; for each cell (index)
+
+.update_loop:               ; do {

 
 

-.update_loop:
-call write_next_cell_state
+    call update_cell

 
 

-inc cx
-cmp cx, COLS * ROWS
-jl .update_loop             ; for i in [0 .. COLS * ROWS - 1]
+    dec cx
+    jns .update_loop        ; } while (--cx > 0)

 
 ret
 
 
 ret
 

diff --git a/prototype.c b/prototype.c
deleted file mode 100644 (file)
index 83b9398..0000000
--- a/prototype.c
+++ /dev/null
@@ -1,134 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-
-#define COLS 80
-#define ROWS 25
-
-#define DEAD ' '
-#define ALIVE '#'
-
-#define INIT_RATIO 4
-
-#define STR(x) _STR (x)
-#define _STR(x) #x
-
-static uint16_t xss; /* xs() state */
-
-static uint16_t
-xs () /* xorshift prng */
-{
-  xss ^= (xss << 1);
-  xss ^= (xss >> 3);
-  xss ^= (xss << 10);
-
-  return xss;
-}
-
-static void
-clearscr ()
-{
-  printf ("\e[1;1H\e[2J");
-}
-
-static void
-print_row (char row[COLS])
-{
-  printf ("%." STR (COLS) "s\n", row);
-}
-
-static void
-print_grid (char grid[COLS * ROWS])
-{
-  for (int i = 0; i < ROWS; i++)
-    print_row (grid + i * COLS);
-}
-
-static void
-init_grid (char grid[COLS * ROWS])
-{
-  for (int i = 0; i < COLS * ROWS; i++)
-    {
-      if (xs () % INIT_RATIO)
-        grid[i] = DEAD;
-      else
-        grid[i] = ALIVE;
-    }
-}
-
-static char
-get_state (char grid[COLS * ROWS], int row, int col)
-{
-  if (row < 0 || row >= ROWS || col < 0 || col >= COLS)
-    return DEAD;
-
-  return grid[row * COLS + col];
-}
-
-static int
-alive_neighbours (char grid[COLS * ROWS], int idx)
-{
-  int row = idx / COLS;
-  int col = idx % COLS;
-  int neighbours = 0;
-
-  for (int i = -1; i <= 1; i++)
-    for (int j = -1; j <= 1; j++)
-      if (get_state (grid, row + i, col + j) == ALIVE)
-        neighbours++;
-
-  if (get_state (grid, row, col) == ALIVE)
-    neighbours--;
-
-  return neighbours;
-}
-
-static char
-next_state (char grid[COLS * ROWS], int idx)
-{
-  int n = alive_neighbours (grid, idx);
-
-  if (get_state (grid, idx / COLS, idx % COLS) == ALIVE)
-    {
-      if (n < 2 || n > 3)
-        return DEAD;
-
-      return ALIVE;
-    }
-
-  if (n == 3)
-    return ALIVE;
-
-  return DEAD;
-}
-
-static void
-update_grid (char grid[COLS * ROWS])
-{
-  char new[COLS * ROWS];
-
-  for (int i = 0; i < COLS * ROWS; i++)
-    new[i] = next_state (grid, i);
-
-  memcpy (grid, new, COLS * ROWS);
-}
-
-int
-main ()
-{
-  char grid[COLS * ROWS];
-
-  xss = time (0);
-  init_grid (grid);
-
-  do
-    {
-      clearscr ();
-      print_grid (grid);
-      update_grid (grid);
-    }
-  while (getchar () != 'q');
-
-  return 0;
-}