graphic tictactoe

Hex & octal digits

7 files changed, 173 insertions, 12 deletions

diff --git a/chapter31/src/test/java/com/seaofnodes/simple/Chapter01Test.java b/chapter31/src/test/java/com/seaofnodes/simple/Chapter01Test.java
index fa7fb68a..6db79c16 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/Chapter01Test.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/Chapter01Test.java
@@ -41,13 +41,8 @@ public class Chapter01Test {
     }
 
     @Test
-    public void testBad2() {
-        try {
-            new CodeGen("return 0123;").parse();
-            fail();
-        } catch( RuntimeException e ) {
-            assertEquals("Syntax error: integer values cannot start with '0'",e.getMessage());
-        }
+    public void testOctal() {
+        assertEquals("return 83;",new CodeGen("return 0123;").parse().print());
     }
 
     @Test
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/Chapter21Test.java b/chapter31/src/test/java/com/seaofnodes/simple/Chapter21Test.java
index c6d558eb..1a57d4da 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/Chapter21Test.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/Chapter21Test.java
@@ -531,7 +531,8 @@ val sieve = { int N ->
         String sprimes = sb.p("]").toString();
 
         // Compile, link against native C; expect the above string of primes to be printed out by C
-        TestC.runC(src, "sieve", sprimes,344);
+        // Load/Phi hoisting now requires the pointer before the loop entry.
+        TestC.runC(src, "sieve", sprimes,216);
 
         // Evaluate on RISC5 emulator; expect return of an array of primes in
         // the simulated heap.
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java b/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java
index 44cdbada..3b71bd2a 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/Chapter25Test.java
@@ -475,9 +475,9 @@ public class Chapter25Test {
 
         // Elf files are sane
 
-        // Sys includes the graphics interface; its native backend is optional.
+        // Software drawing and the optional native graphics interface.
         assertArrayEquals(new String[]{"sys/adt", "sys/ary",
-            "sys/aryi64", "sys/aryu8", "sys/char", "sys/gfx", "sys/io", "sys/libc", "sys/rt", "sys/scan", "sys/text"},sys_elf._deps);
+            "sys/aryi64", "sys/aryu8", "sys/char", "sys/draw", "sys/gfx", "sys/io", "sys/libc", "sys/rt", "sys/scan", "sys/text"},sys_elf._deps);
         assertArrayEquals(new String[]{"sys"},sys_elf._units);
         assertSame("class:sys" ,sys_elf._clz._name);
     }
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java b/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java
new file mode 100644
index 00000000..b3e8edd0
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java
@@ -0,0 +1,102 @@
+package com.seaofnodes.simple;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+
+// Native raster and game checks; no backend or display is needed.
+public class DrawTest {
+    @Test public void rectanglesAndColors() throws Exception {
+        TestC.runSYS("""
+            val main = { ->
+                val c = new sys.draw.Canvas(12,10);
+                u32 color = sys.draw.rgb(300,-1,128);
+                if( color!=16711808 ) return 1;
+                c.clear(7).fillRect(-2,-1,5,4,color);
+                for( int y=0; y<10; y++ )
+                    for( int x=0; x<12; x++ )
+                        if( c.pixels[y*12+x]!=(x<3 && y<3 ? color : 7) ) return 2;
+                c.clear(0).rect(2,2,7,6,1,9);
+                for( int y=0; y<10; y++ )
+                    for( int x=0; x<12; x++ ) {
+                        var inside = 2<=x<9 && 2<=y<8;
+                        var border = inside && (x==2 || x==8 || y==2 || y==7);
+                        if( c.pixels[y*12+x]!=(border ? 9 : 0) ) return 3;
+                    }
+                c.clear(5).fillRect(20,0,8,8,1).rect(0,0,12,10,0,1);
+                c.fillRect(0,0,-1,5,1).pixel(-1,0,1).pixel(12,9,1);
+                for( int i=0; i<c.pixels#; i++ ) if( c.pixels[i]!=5 ) return 4;
+                return 0;
+            };
+            ""","drawRectangles","",-1);
+    }
+
+    @Test public void circlesLinesAndText() throws Exception {
+        TestC.runSYS("""
+            val main = { ->
+                val c = new sys.draw.Canvas(16,16);
+                c.fillCircle(8,8,3,1);
+                for( int y=0; y<16; y++ )
+                    for( int x=0; x<16; x++ )
+                        if( c.pixels[y*16+x]!=((x-8)*(x-8)+(y-8)*(y-8)<=9 ? 1 : 0) ) {
+                            sys.io.p("circle mismatch %(x) %(y): %(c.pixels[y*16+x])\\n");
+                            return 1;
+                        }
+                c.clear(0).circle(8,8,3,1,2);
+                if( c.pixels[8*16+8]!=0 || c.pixels[8*16+11]!=2 || c.pixels[8*16+10]!=0 ) return 2;
+                c.clear(0).circle(8,8,3,3,2);
+                if( c.pixels[8*16+8]!=2 ) return 8;
+                c.clear(0).line(-5,8,20,8,3,3);
+                for( int y=0; y<16; y++ )
+                    for( int x=0; x<16; x++ )
+                        if( c.pixels[y*16+x]!=(7<=y<=9 ? 3 : 0) ) return 3;
+                c.clear(0).line(8,8,8,8,2,4);
+                if( c.pixels[8*16+8]!=4 || c.pixels[8*16+9]!=4 || c.pixels[9*16+9]!=0 ) return 4;
+                c.clear(0).line(2,2,13,13,1,5);
+                if( c.pixels[7*16+7]!=5 || c.pixels[7*16+8]!=0 ) return 5;
+                c.clear(0).text(0,0,"x",1,6).text(8,0,"X",1,6);
+                for( int y=0; y<5; y++ )
+                    for( int x=0; x<3; x++ )
+                        if( c.pixels[y*16+x]!=c.pixels[y*16+x+8] ) return 6;
+                c.clear(0).fillCircle(-1,-1,2,7);
+                if( c.pixels[0]!=7 || c.pixels[2]!=0 ) return 7;
+                return 0;
+            };
+            ""","drawCurves","",-1);
+    }
+
+    @Test public void graphicalGameWithoutWindow() throws Exception {
+        String game=Files.readString(Path.of("docs/examples/TicTacToeGraphical.smp"))
+            .replace("val main =","val _windowMain =");
+        TestC.runSYS(game+"""
+
+            val main = { ->
+                val board = new u8[9];
+                _reset(board);
+                if( _square(48,168)!=0 || _square(551,671)!=8 || _square(552,400)!=-1 || _square(100,167)!=-1 ) return 1;
+                if( !_move(board,4) || board[4]!='X' || board[0]!='O' ) return 2;
+                if( _move(board,4) || _move(board,0) || _move(board,-1) || _move(board,9) ) return 3;
+                val moves = "1879";
+                _reset(board);
+                for( int i=0; i<moves#; i++ )
+                    if( !_move(board,moves[i]-'1') ) return 4;
+                if( _winner(board)!='X' || _move(board,1) ) return 5;
+                val screen = new sys.draw.Canvas(600,780);
+                _draw(screen,board,-1);
+                if( screen.pixels[252*600+132]==screen.pixels[0] ) return 6;
+                _reset(board);
+                val draw = "12768";
+                for( int i=0; i<draw#; i++ ) _move(board,draw[i]-'1');
+                if( !_finished(board) || _winner(board)!=0 ) return 7;
+                _reset(board);
+                _move(board,0); _move(board,1); _move(board,3);
+                if( _winner(board)!='O' ) return 8;
+                _draw(screen,board,-1);
+                _reset(board);
+                if( _finished(board) ) return 9;
+                _draw(screen,board,4);
+                return 0;
+            };
+            ""","drawGame","",-1);
+    }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java b/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
index 2e9c8dbc..9c432ce4 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
@@ -10,7 +10,7 @@ import static org.junit.Assert.*;
 
 // These tests never open a window and do not need MiniFB installed.
 public class GraphicsTest {
-    private static String graphics, text;
+    private static String graphics, text, game;
 
     @BeforeClass public static void compilePrograms() throws Exception {
         var paths = new Ary<>(new String[]{TestC.RELEASE_SYS_DIR});
@@ -18,6 +18,8 @@ public class GraphicsTest {
             "graphics_missing",paths,TestC.CALL_CONVENTION,null,null,-1);
         text = TestC.compile("val main={ -> sys.io.p(\"text still works\\n\"); return 0; };",
             "graphics_text",paths,TestC.CALL_CONVENTION,null,null,-1);
+        game = TestC.compile(Files.readString(Path.of("docs/examples/TicTacToeGraphical.smp")),
+            "graphics_game",paths,TestC.CALL_CONVENTION,null,null,-1);
     }
 
     private static String run(String exe, String backend, int exit) throws Exception {
@@ -43,6 +45,10 @@ public class GraphicsTest {
         assertTrue(run(graphics,"off",1).contains("disabled"));
     }
 
+    @Test public void gameWithoutBackend() throws Exception {
+        assertTrue(run(game,"off",1).contains("disabled"));
+    }
+
     @Test public void missingLibrary() throws Exception {
         String missing = Path.of("build","no-such-minifb-backend").toAbsolutePath().toString();
         String output = run(graphics,missing,1);
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/IntegerLiteralTest.java b/chapter31/src/test/java/com/seaofnodes/simple/IntegerLiteralTest.java
new file mode 100644
index 00000000..975042c2
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/IntegerLiteralTest.java
@@ -0,0 +1,46 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeFloat;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class IntegerLiteralTest {
+    private static void value(String expression, long expected) {
+        var code = new CodeGen("return "+expression+";").parse();
+        assertEquals(expression,TypeInteger.constant(expected),code.expr()._type);
+    }
+
+    @Test public void valuesAndBitPatterns() {
+        value("0x00e47b57",14973783);
+        value("0XfF",255);
+        value("025755",11245); // A: rows 010, 101, 111, 101, 101.
+        value("000000",0);
+        value("0x7fffffffffffffff",Long.MAX_VALUE);
+        value("0x8000000000000000",Long.MIN_VALUE);
+        value("0xffffffffffffffff",-1);
+        value("0777777777777777777777",Long.MAX_VALUE);
+        value("01000000000000000000000",Long.MIN_VALUE);
+        value("01777777777777777777777",-1);
+        value("0x00000000000000000001",1);
+        value("-0x2a + 052",0);
+        value("0x1e+2",32); // e and f are hex digits, not float markers.
+        value("0xff & 017",15);
+        value("017<<0x4",240);
+        value("0x0f",15);
+        value("0123",83);
+        value("000000000000000000000000000000000001",1);
+        assertEquals(TypeFloat.constant(12.5),new CodeGen("return 012.5;").parse().expr()._type);
+        assertEquals(TypeFloat.constant(12.0),new CodeGen("return 012f;").parse().expr()._type);
+    }
+
+    @Test public void nativeLiterals() throws Exception {
+        TestC.runSF("""
+            val check_noInline = { i64 mask, u32 color, int glyph ->
+                return mask==-1 && color==14973783 && glyph==11245 ? 0 : 1;
+            };
+            val main = { -> return check_noInline(0xffffffffffffffff,0x00e47b57,025755); };
+            ""","basedLiterals","",-1);
+    }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java
index 2b7eea78..ef26a943 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ParserDiagnosticTest.java
@@ -30,7 +30,18 @@ public class ParserDiagnosticTest {
         diagnostic("return 9223372036854775808;",1,8,"Integer literal is outside the signed 64-bit range");
         diagnostic("return 1e;",1,8,"Invalid floating-point literal '1e'");
         diagnostic("return 1.2.3f;",1,8,"Invalid floating-point literal '1.2.3f'");
-        diagnostic("return 012;",1,8,"Syntax error: integer values cannot start with '0'");
+        diagnostic("return 018;",1,8,"Invalid octal integer literal '018'");
+    }
+
+    @Test public void testBasedIntegerLiteralErrors() {
+        diagnostic("return 0x;",1,8,"Hexadecimal integer literal requires at least one digit");
+        diagnostic("return 0x12g;",1,8,"Invalid hexadecimal integer literal '0x12g'");
+        diagnostic("return 0128;",1,8,"Invalid octal integer literal '0128'");
+        diagnostic("return 0x_ff;",1,8,"Invalid hexadecimal integer literal '0x_ff'");
+        diagnostic("return 09;",1,8,"Invalid octal integer literal '09'");
+        diagnostic("return 0x10000000000000000;",1,8,"Hexadecimal integer literal exceeds 64 bits");
+        diagnostic("return 02000000000000000000000;",1,8,"Octal integer literal exceeds 64 bits");
+        diagnostic("int 0xabc;",1,5,"Expected an identifier, found '0xabc'");
     }
 
     @Test public void testUnclosedCommentsAndStrings() {