summaryrefslogtreecommitdiff
path: root/chapter31/src
diff options
context:
space:
mode:
authorCliff Click <cliffc@acm.org>2026-11-15 11:20:40 -0800
committerCliff Click <cliffc@acm.org>2026-11-15 11:20:40 -0800
commitf0a6c6757a795b8e186de0076836a87acef59fa7 (patch)
treeef45c1b58093420bbd2de6647274139e46539bfe /chapter31/src
parent7e66b7ae6b00a2e1652db32f01f0bf480508ef05 (diff)
downloadSimple-f0a6c6757a795b8e186de0076836a87acef59fa7.tar.gz
Simple-f0a6c6757a795b8e186de0076836a87acef59fa7.zip
Graphics now allow resizemain
Reorganize docs. Fix bugs X86 LOad+cmp scheduling. Math intrinsics
Diffstat (limited to 'chapter31/src')
-rw-r--r--chapter31/src/main/c/simple_crt.c10
-rw-r--r--chapter31/src/main/c/simple_graphics.c8
-rw-r--r--chapter31/src/main/c/simple_graphics.h5
-rw-r--r--chapter31/src/main/c/simple_minifb.c39
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/GlobalCodeMotion.java10
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/ListScheduler.java2
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java12
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/ModFNode.java49
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/ModNode.java16
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/Node.java3
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/ModARM.java29
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java3
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/DivRISC.java17
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java1
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/CmpX86.java7
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/DivX86.java36
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java28
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/parser/Construction.java3
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/parser/Expressions.java4
-rw-r--r--chapter31/src/main/java/com/seaofnodes/simple/parser/Lexer.java4
-rw-r--r--chapter31/src/main/smp/sys.smp2
-rw-r--r--chapter31/src/main/smp/sys/audio.md84
-rw-r--r--chapter31/src/main/smp/sys/audio.smp1
-rw-r--r--chapter31/src/main/smp/sys/draw.smp1
-rw-r--r--chapter31/src/main/smp/sys/draw/Canvas.smp68
-rw-r--r--chapter31/src/main/smp/sys/draw/README.md124
-rw-r--r--chapter31/src/main/smp/sys/gfx.md154
-rw-r--r--chapter31/src/main/smp/sys/gfx.smp19
-rw-r--r--chapter31/src/main/smp/sys/math.smp12
-rw-r--r--chapter31/src/main/smp/sys/text.smp2
-rw-r--r--chapter31/src/main/smp/sys/time.smp26
-rw-r--r--chapter31/src/main/smp/sys/time/README.md133
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java1
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java2
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java61
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/Eval2.java3
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java58
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/MathTest.java79
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/ModTest.java201
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/SchedulingTest.java47
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/StreamIOTest.java2
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/StringFormatTest.java5
-rw-r--r--chapter31/src/test/java/com/seaofnodes/simple/TestC.java2
43 files changed, 1291 insertions, 82 deletions
diff --git a/chapter31/src/main/c/simple_crt.c b/chapter31/src/main/c/simple_crt.c
index 39708629..e50042c2 100644
--- a/chapter31/src/main/c/simple_crt.c
+++ b/chapter31/src/main/c/simple_crt.c
@@ -3,6 +3,7 @@
#include <stdlib.h>
#include <string.h>
#include <errno.h>
+#include <math.h>
#include <termios.h>
#include <unistd.h>
@@ -19,6 +20,15 @@ double simple_f64_from_bits(int64_t bits) {
return value;
}
+// Floating remainder's machine instruction uses this memory-preserving helper.
+double simple_f64_mod(double x, double y) {
+ // fmod can set errno for NaN-producing inputs; arithmetic leaves it alone.
+ int saved_errno = errno;
+ double result = fmod(x, y);
+ errno = saved_errno;
+ return result;
+}
+
// errno may be thread-local or a macro calling a platform accessor.
int32_t simple_errno(void) { return errno; }
int32_t simple_set_errno(int32_t error) { errno = error; return -1; }
diff --git a/chapter31/src/main/c/simple_graphics.c b/chapter31/src/main/c/simple_graphics.c
index 40d66ba9..a35c28a6 100644
--- a/chapter31/src/main/c/simple_graphics.c
+++ b/chapter31/src/main/c/simple_graphics.c
@@ -74,7 +74,8 @@ static int load_graphics(void) {
if (!candidate || candidate->version != SIMPLE_GRAPHICS_VERSION ||
!candidate->open || !candidate->present || !candidate->poll ||
!candidate->mouse_x || !candidate->mouse_y || !candidate->button ||
- !candidate->key || !candidate->close || !candidate->wait) {
+ !candidate->key || !candidate->close || !candidate->wait ||
+ !candidate->width || !candidate->height || !candidate->present_size) {
fprintf(stderr, "Simple graphics: incompatible MiniFB backend '%s'. Rebuild with make graphics.\n", path);
dlclose(library);
library = NULL;
@@ -93,6 +94,11 @@ int32_t simple_gfx_open(const char *title, uint32_t width, uint32_t height) {
int32_t simple_gfx_present(const uint32_t *pixels, uint32_t count) {
return api ? api->present(pixels, count) : -1;
}
+int32_t simple_gfx_present_size(const uint32_t *pixels, uint32_t count, uint32_t width, uint32_t height) {
+ return api ? api->present_size(pixels, count, width, height) : -1;
+}
+uint32_t simple_gfx_width(void) { return api ? api->width() : 0; }
+uint32_t simple_gfx_height(void) { return api ? api->height() : 0; }
int32_t simple_gfx_poll(int32_t wait) { return api ? api->poll(wait) : -1; }
int32_t simple_gfx_mouse_x(void) { return api ? api->mouse_x() : 0; }
int32_t simple_gfx_mouse_y(void) { return api ? api->mouse_y() : 0; }
diff --git a/chapter31/src/main/c/simple_graphics.h b/chapter31/src/main/c/simple_graphics.h
index 370256be..d19cac46 100644
--- a/chapter31/src/main/c/simple_graphics.h
+++ b/chapter31/src/main/c/simple_graphics.h
@@ -15,6 +15,9 @@ struct simple_graphics_api {
int32_t (*key)(int32_t);
void (*close)(void);
int32_t (*wait)(int64_t);
+ uint32_t (*width)(void);
+ uint32_t (*height)(void);
+ int32_t (*present_size)(const uint32_t *, uint32_t, uint32_t, uint32_t);
};
-#define SIMPLE_GRAPHICS_VERSION 2
+#define SIMPLE_GRAPHICS_VERSION 3
#endif
diff --git a/chapter31/src/main/c/simple_minifb.c b/chapter31/src/main/c/simple_minifb.c
index 2117f0d2..86f110c3 100644
--- a/chapter31/src/main/c/simple_minifb.c
+++ b/chapter31/src/main/c/simple_minifb.c
@@ -14,11 +14,19 @@
#include "x11/WindowData_X11.h"
#endif
-// One fixed-size window for now. No Simple pointer survives a native call:
+// One resizable window. No Simple pointer survives a native call:
// MiniFB retains its last draw buffer for OS repaint events, so copy it here.
static struct mfb_window *window;
static uint32_t *frame;
static uint32_t width, height;
+static size_t capacity;
+
+static uint32_t window_width(void) { return window ? mfb_get_window_width(window) : 0; }
+static uint32_t window_height(void) { return window ? mfb_get_window_height(window) : 0; }
+
+static void resize_window(struct mfb_window *w, int x, int y) {
+ if (x > 0 && y > 0) mfb_set_viewport(w, 0, 0, (unsigned)x, (unsigned)y);
+}
// The C-only build never installs the upstream C++ callback wrappers.
void release_cpp_stub(struct mfb_window *unused) { (void)unused; }
@@ -31,6 +39,7 @@ static void close_window(void) {
}
free(frame);
frame = NULL;
+ capacity = 0;
}
static int32_t open_window(const char *title, uint32_t w, uint32_t h) {
@@ -44,7 +53,8 @@ static int32_t open_window(const char *title, uint32_t w, uint32_t h) {
fprintf(stderr, "Simple graphics: cannot allocate the display buffer.\n");
return -1;
}
- window = mfb_open(title, w, h);
+ capacity = (size_t)w * h;
+ window = mfb_open_ex(title, w, h, MFB_WF_RESIZABLE);
if (!window) {
fprintf(stderr, "Simple graphics: MiniFB could not open a window (is a graphical display available?).\n");
close_window();
@@ -52,6 +62,7 @@ static int32_t open_window(const char *title, uint32_t w, uint32_t h) {
}
width = w;
height = h;
+ mfb_set_resize_callback(window, resize_window);
return 0;
}
@@ -67,14 +78,29 @@ static int32_t status(mfb_update_state state) {
return -1;
}
-static int32_t present(const uint32_t *pixels, uint32_t count) {
+static int32_t present_size(const uint32_t *pixels, uint32_t count, uint32_t w, uint32_t h) {
if (!window) return 1;
- if (!pixels || count != (uint64_t)width * height) {
+ if (!pixels || !w || !h || w > UINT32_MAX / 4 ||
+ count != (uint64_t)w * h || (uint64_t)w * h > SIZE_MAX / 4) {
fprintf(stderr, "Simple graphics: pixel array length must equal width * height.\n");
return -1;
}
+ if (count > capacity) {
+ uint32_t *larger = realloc(frame, (size_t)count * sizeof(*frame));
+ if (!larger) {
+ fprintf(stderr, "Simple graphics: cannot resize the display buffer.\n");
+ return -1;
+ }
+ frame = larger;
+ capacity = count;
+ }
memcpy(frame, pixels, (size_t)count * sizeof(*frame));
- return status(mfb_update_ex(window, frame, width, height));
+ return status(mfb_update_ex(window, frame, w, h));
+}
+
+// Compatibility for clients drawing at their original resolution.
+static int32_t present(const uint32_t *pixels, uint32_t count) {
+ return present_size(pixels, count, width, height);
}
static int32_t wait_events(int64_t timeout) {
@@ -109,7 +135,8 @@ static int32_t key(int32_t k) {
static const struct simple_graphics_api api = {
SIMPLE_GRAPHICS_VERSION, open_window, present, poll_events,
- mouse_x, mouse_y, button, key, close_window, wait_events
+ mouse_x, mouse_y, button, key, close_window, wait_events,
+ window_width, window_height, present_size
};
#ifdef _WIN32
__declspec(dllexport)
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/GlobalCodeMotion.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/GlobalCodeMotion.java
index 86cb2e98..83c0677d 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/GlobalCodeMotion.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/GlobalCodeMotion.java
@@ -141,10 +141,11 @@ public abstract class GlobalCodeMotion {
if( def!=null && !(def instanceof PhiNode) )
_schedEarly(def,code,start);
- // An existing edge 0 already supplies control (or a Phi/Proj binding).
- if( n.in(0)==null ) {
+ // A memory op's control is a lower bound, not a complete early schedule:
+ // instruction selection may have folded in an operand defined later.
+ if( n.in(0)==null || n instanceof MemOpNode ) {
// Schedule at deepest input
- CFGNode early = start; // Maximally early, lowest idepth
+ CFGNode early = n.in(0) instanceof CFGNode ctrl ? ctrl : start;
for( int i=1; i<n.nIns(); i++ )
if( n.in(i)!=null && n.in(i).cfg0().idepth() > early.idepth() )
early = n.in(i).cfg0(); // Latest/deepest input
@@ -251,6 +252,9 @@ public abstract class GlobalCodeMotion {
if( use != null )
lca = use_block(n,use, late).domLCA(lca,null);
+ assert lca!=null && early.dominates(lca,null) :
+ "Early schedule must dominate uses of "+n.getClass().getSimpleName()+"#"+n._nid;
+
// Loads may need anti-dependencies, raising their LCA
if( n instanceof MemOpNode load && load._isLoad )
lca = find_anti_dep(lca,load,early,late,anti, antideps);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/ListScheduler.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/ListScheduler.java
index c3b603e5..f90d8d4e 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/ListScheduler.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/ListScheduler.java
@@ -49,7 +49,7 @@ public abstract class ListScheduler {
else
computeSingleRDef(bb,n);
- if( n instanceof NewNode || n instanceof CallNode )
+ if( n instanceof NewNode || n instanceof CallNode || n instanceof ModFNode )
bb.fun()._hasCalls = true;
return this;
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java b/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
index 1b335c50..303fd355 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
@@ -184,6 +184,7 @@ public class RegAlloc {
if( bb instanceof CallEndMach cend ) cend.cacheRegs(_code);
for( Node n : bb._outputs )
if( n instanceof NewNode nnn ) nnn.cacheRegs(_code);
+ else if( n instanceof ModFNode mod ) mod.cacheRegs(_code);
}
// Expensive assert: useful when chasing cross-function allocator edges.
//assert verifyFunctionLocalEdges();
@@ -680,7 +681,14 @@ public class RegAlloc {
if( cfg==def.cfg0() && def.nOuts()==1 && !singleReg )
return;
}
- makeSplit(def,kind,round,lrg,umask).insertBefore(n, i);
+ // If isolating a loop Phi's uses did not relieve pressure, cloning its
+ // constant input again cannot help: it still forces the Phi into a GPR.
+ // A real transfer on this retry lets the Phi live on the stack.
+ Node split = n instanceof PhiNode phi && phi.region() instanceof LoopNode &&
+ lrg._machUse instanceof SplitNode prior && prior._round<round &&
+ !lrg._mask.isEmpty() && def instanceof MachNode mach && mach.isClone()
+ ? makeSplit(kind,round,lrg) : makeSplit(def,kind,round,lrg,umask);
+ split.insertBefore(n, i);
// Keep the def-side transfer: a kill between the two copies may be
// exactly why this range split. Coalescing can join them when safe.
}
@@ -742,6 +750,8 @@ public class RegAlloc {
// Raise frame size by max stack args passed to New
if( n instanceof NewNode nnn )
maxReg = Math.max(maxReg,nnn._xslot);
+ if( n instanceof ModFNode mod )
+ maxReg = Math.max(maxReg,mod._xslot);
if( !(n instanceof SplitNode ) ) continue;
int defreg = lrg(n )._reg;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/ModFNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/ModFNode.java
new file mode 100644
index 00000000..17d7e36c
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/ModFNode.java
@@ -0,0 +1,49 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.isa.Arm64;
+import com.seaofnodes.isa.RiscV;
+import com.seaofnodes.isa.X86;
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.SB;
+
+/** Floating remainder has no SSE/ARM/RISC-V instruction: emit a helper call. */
+public class ModFNode extends MachConcreteNode implements MachNode {
+ private RegMask _lhs, _rhs, _ret, _kills;
+ public int _xslot;
+ public ModFNode(ModNode mod) { super(mod); }
+ @Override public String op() { return "modf"; }
+ public void cacheRegs(CodeGen code) {
+ TypeFunPtr sig=TypeFunPtr.make(false,new Type[]{TypeFloat.F64,TypeFloat.F64},TypeFloat.F64);
+ _lhs=code._mach.callArgMask(sig,2,0,code._cCallingConv);
+ _rhs=code._mach.callArgMask(sig,3,0,code._cCallingConv);
+ _ret=code._mach.retMask(sig);
+ RegMaskRW kills=code._cCallerSave.copy();
+ if( code._mach instanceof arm ) kills.set(arm.FLAGS);
+ int base=code._mach.regs().length+cfg0().fun()._maxArgSlot;
+ _xslot=base+code._mach.maxArgSlot(sig,code._cCallingConv);
+ for( int i=base; i<_xslot; i++ ) kills.set(i);
+ _kills=kills;
+ }
+ @Override public RegMask regmap(int i) { return i==1 ? _lhs : i==2 ? _rhs : null; }
+ @Override public RegMask outregmap() { return _ret; }
+ @Override public RegMask killmap() { return _kills; }
+ @Override public void encoding(Encoding enc) {
+ enc.external(this,"simple_f64_mod");
+ switch( machine().name() ) {
+ case "x86_64_v2" -> X86.call(enc);
+ case "arm" -> enc.add4(Arm64.b(Arm64.OP_CALL,0));
+ case "riscv" -> {
+ enc.add4(RiscV.u_type(RiscV.OP_AUIPC,riscv.T0,0));
+ enc.add4(RiscV.i_type(RiscV.OP_JALR,riscv.RPC,0,riscv.T0,0));
+ }
+ default -> throw new IllegalStateException(machine().name());
+ }
+ }
+ @Override public void asm(CodeGen code, SB sb) {
+ sb.p(code.reg(this)).p(" = ").p(code.reg(in(1))).p(" % ").p(code.reg(in(2)));
+ }
+ @Override public String comment() { return "call simple_f64_mod"; }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/ModNode.java b/chapter31/src/main/java/com/seaofnodes/simple/node/ModNode.java
new file mode 100644
index 00000000..7c1a9238
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/ModNode.java
@@ -0,0 +1,16 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.type.TypeInteger;
+
+public class ModNode extends ArithNode {
+ public ModNode(Node lhs, Node rhs) { super(null,lhs,rhs); }
+ public ModNode(Node lhs, Node rhs, byte mode) { super(null,lhs,rhs,mode); }
+ @Override public Tag serialTag() { return Tag.Mod; }
+ @Override public String op() { return "%"; }
+ @Override boolean allowFloat() { return true; }
+
+ @Override long doOp(long x, long y) { return y==0 ? 0 : x%y; }
+ @Override double doOp(double x, double y) { return x%y; }
+ @Override TypeInteger doOp(TypeInteger x, TypeInteger y) { return TypeInteger.BOT; }
+ @Override Node copy(Node lhs, Node rhs) { return new ModNode(lhs,rhs,_mode); }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java
index d4c0794c..ad4f47e0 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -77,7 +77,7 @@ public abstract class Node extends BaseNode<Node> implements Cloneable {
New,Never,Not,Or,Parm,Phi,Proj,PtrToInt,
ReadOnly,Return,Region,RoundF32,
Sar,Shl,Shr,Start,StartCU,StopCU,Stop,Store,Sub,
- ToInteger,ToFloat,XCtrl,Xor,F64Bits,F64FromBits;
+ ToInteger,ToFloat,XCtrl,Xor,F64Bits,F64FromBits,Mod;
public static final Tag[] VALS = values();
public Node make( BAOS bais, String[] strs, Type[] types, GlobalBits fileAliases, GlobalBits aliases ) {
return switch(this) {
@@ -117,6 +117,7 @@ public abstract class Node extends BaseNode<Node> implements Cloneable {
case Call -> CallNode.make(bais,strs);
case CallEnd-> CallEndNode.make(bais ,types);
case CLInit -> new CLInitNode(bais,strs);
+ case Mod -> new ModNode(null,null,(byte)bais.packed1());
case CProj -> CProjNode.make(bais,strs);
case Con -> ConstantNode.make(bais ,types);
case Escape-> EscapeNode.make(bais ,types);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/ModARM.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/ModARM.java
new file mode 100644
index 00000000..bd29ba3f
--- /dev/null
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/ModARM.java
@@ -0,0 +1,29 @@
+package com.seaofnodes.simple.node.cpus.arm;
+
+import com.seaofnodes.isa.Arm64;
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.util.SB;
+
+public class ModARM extends MachConcreteNode implements MachNode {
+ private static final RegMask REGS=new RegMask(arm.WR_BITS & ~(1L<<arm.X16));
+ ModARM(Node mod) { super(mod); }
+ @Override public String op() { return "mod"; }
+ @Override public RegMask regmap(int i) { return REGS; }
+ @Override public RegMask outregmap() { return REGS; }
+ @Override public RegMask killmap() { return new RegMask(1L<<arm.X16,1L); }
+ @Override public void encoding(Encoding enc) {
+ int lhs=enc.reg(in(1)), rhs=enc.reg(in(2)), dst=enc.reg(this);
+ enc.add4(Arm64.imm_inst(Arm64.OPI_CMP,0,rhs,31)); // CMP rhs,0
+ enc.add4(Arm64.b_cond(Arm64.OP_BRANCH,20,Arm64.COND.EQ));
+ enc.add4(Arm64.madd(Arm64.OP_DIV,rhs,3,lhs,arm.X16)); // SDIV x16,lhs,rhs
+ enc.add4(Arm64.madd(Arm64.OP_MUL,rhs,31,arm.X16,arm.X16)); // MUL x16,x16,rhs
+ enc.add4(Arm64.r_reg(Arm64.OP_SUB,0,arm.X16,0,lhs,dst)); // SUB dst,lhs,x16
+ enc.add4(Arm64.b(Arm64.OP_UJMP,8));
+ enc.add4(Arm64.mov(Arm64.OP_MOVZ,0,0,dst));
+ }
+ @Override public void asm(CodeGen code, SB sb) {
+ sb.p(code.reg(this)).p(" = ").p(code.reg(in(1))).p(" % ").p(code.reg(in(2)));
+ }
+ @Override public String comment() { return "SDIV/MUL/SUB; kill x16, flags; zero guarded"; }
+}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java
index 2d47edf5..55a9cdb0 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/arm/arm.java
@@ -28,7 +28,7 @@ public class arm extends Machine {
public static final int D16 = 48, D17 = 49, D18 = 50, D19 = 51, D20 = 52, D21 = 53, D22 = 54, D23 = 55;
public static final int D24 = 56, D25 = 57, D26 = 58, D27 = 59, D28 = 60, D29 = 61, D30 = 62, D31 = 63;
- static final int FLAGS = 64;
+ public static final int FLAGS = 64;
static final int MAX_REG = 65;
public static final int D_OFFSET = 32;
@@ -318,6 +318,7 @@ public class arm extends Machine {
case CProjNode c -> new CProjNode(c);
case ConstantNode con-> con(con);
case DivNode div -> div.mode()==2 ? new DivFARM(div) : new DivARM(div);
+ case ModNode mod -> mod.mode()==2 ? new ModFNode(mod) : new ModARM(mod);
case EscapeNode esc -> new EscapeNode(esc);
case FunNode fun -> new FunARM(fun);
case FunPtrNode fptr -> fptr(fptr);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/DivRISC.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/DivRISC.java
index 515ffa47..691979ec 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/DivRISC.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/DivRISC.java
@@ -1,17 +1,26 @@
package com.seaofnodes.simple.node.cpus.riscv;
+import com.seaofnodes.isa.RiscV;
import com.seaofnodes.simple.util.SB;
import com.seaofnodes.simple.codegen.*;
import com.seaofnodes.simple.node.*;
public class DivRISC extends MachConcreteNode implements MachNode{
- public DivRISC(Node div) {super(div);}
- @Override public String op() { return "div"; }
+ private final boolean _mod;
+ public DivRISC(Node div) {super(div); _mod=div instanceof ModNode;}
+ @Override public String op() { return _mod ? "mod" : "div"; }
@Override public RegMask regmap(int i) { return riscv.RMASK; }
@Override public RegMask outregmap() { return riscv.WMASK; }
- @Override public void encoding( Encoding enc ) { riscv.r_type(enc,this,4,1); }
+ @Override public void encoding( Encoding enc ) {
+ // RISC-V returns -1 for DIV by zero, and the dividend for REM by zero.
+ // Both ideal operations instead return zero.
+ enc.add4(RiscV.b_type(RiscV.OP_BRANCH,1,enc.reg(in(2)),(short)riscv.ZERO,12));
+ enc.add4(RiscV.i_type(RiscV.OP_IMM,enc.reg(this),0,riscv.ZERO,0));
+ enc.add4(RiscV.j_type(RiscV.OP_JAL,riscv.ZERO,8));
+ riscv.r_type(enc,this,_mod ? 6 : 4,1);
+ }
@Override public void asm(CodeGen code, SB sb) {
- sb.p(code.reg(this)).p(" = ").p(code.reg(in(1))).p(" / ").p(code.reg(in(2)));
+ sb.p(code.reg(this)).p(" = ").p(code.reg(in(1))).p(_mod ? " % " : " / ").p(code.reg(in(2)));
}
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java
index 976d1a52..70585732 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/riscv/riscv.java
@@ -222,6 +222,7 @@ public class riscv extends Machine {
case CProjNode c -> new CProjNode(c);
case ConstantNode con -> con(con);
case DivNode div -> div.mode()==2 ? new DivFRISC(div) : new DivRISC(div);
+ case ModNode mod -> mod.mode()==2 ? new ModFNode(mod) : new DivRISC(mod);
case EscapeNode esc -> new EscapeNode(esc);
case FunNode fun -> new FunRISC(fun);
case FunPtrNode fptr -> fptr(fptr);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/CmpX86.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/CmpX86.java
index 7faea17b..f8e652df 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/CmpX86.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/CmpX86.java
@@ -7,6 +7,12 @@ import com.seaofnodes.simple.util.SB;
public class CmpX86 extends MachConcreteNode implements MachNode {
CmpX86( Node add ) { super(add); }
+ private CmpX86(CmpX86 cmp) {
+ super((Node)null);
+ addDef(null);
+ addDef(cmp.in(1));
+ addDef(cmp.in(2));
+ }
@Override public String op() { return "cmp"; }
@Override public RegMask regmap(int i) { return x86_64_v2.RMASK; }
@Override public RegMask outregmap() { return x86_64_v2.FLAGS_MASK; }
@@ -16,6 +22,7 @@ public class CmpX86 extends MachConcreteNode implements MachNode {
// compared to some normal registers - and those normal registers might not
// be spilling!
@Override public boolean isClone() { return true; }
+ @Override public Node copy() { return new CmpX86(this); }
@Override public void encoding( Encoding enc ) {
X86.reg(enc,0x3B,enc.reg(in(1)),enc.reg(in(2)));
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/DivX86.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/DivX86.java
index 9f375a80..7607913f 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/DivX86.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/DivX86.java
@@ -6,20 +6,42 @@ import com.seaofnodes.simple.node.*;
import com.seaofnodes.simple.util.SB;
public class DivX86 extends MachConcreteNode implements MachNode {
- DivX86( Node div ) { super(div); }
- @Override public String op() { return "div"; }
+ private final boolean _mod;
+ DivX86( Node div ) { super(div); _mod=div instanceof ModNode; }
+ @Override public String op() { return _mod ? "mod" : "div"; }
@Override public RegMask regmap(int i) {
return (i==1) ? x86_64_v2.RAX_MASK : x86_64_v2.DIV_MASK;
}
- @Override public RegMask outregmap() { return x86_64_v2.RAX_MASK; }
- @Override public RegMask killmap() { return x86_64_v2.RDX_MASK; }
+ @Override public RegMask outregmap() { return _mod ? x86_64_v2.RDX_MASK : x86_64_v2.RAX_MASK; }
+ @Override public RegMask killmap() {
+ return new RegMask((1L<<(_mod ? x86_64_v2.RAX : x86_64_v2.RDX)) | (1L<<x86_64_v2.FLAGS));
+ }
@Override public void encoding( Encoding enc ) {
- X86.divide(enc,enc.reg(in(2)));
+ int rhs=enc.reg(in(2)), dst=enc.reg(this);
+ // IDIV faults on zero and MIN_VALUE/-1. Handle both before issuing it.
+ X86.reg(enc,0x85,rhs,rhs); // TEST rhs,rhs
+ enc.add1(0x0F).add1(0x84);
+ int zero=enc._bits.size(); enc.add4(0); // JZ zero
+ X86.imm(enc,0x81,7,rhs,-1); // CMP rhs,-1
+ enc.add1(0x0F).add1(0x85);
+ int divide=enc._bits.size(); enc.add4(0); // JNE divide
+ if( _mod ) X86.reg(enc,0x33,dst,dst);
+ else X86.unary(enc,0xF7,3,dst); // NEG wraps MIN_VALUE, like ideal division.
+ enc.add1(0xE9);
+ int minusOne=enc._bits.size(); enc.add4(0); // JMP done
+ enc.patch4(divide,enc._bits.size()-divide-4);
+ X86.divide(enc,rhs);
+ enc.add1(0xE9);
+ int done=enc._bits.size(); enc.add4(0); // JMP done
+ enc.patch4(zero,enc._bits.size()-zero-4);
+ X86.reg(enc,0x33,dst,dst);
+ enc.patch4(minusOne,enc._bits.size()-minusOne-4);
+ enc.patch4(done,enc._bits.size()-done-4);
}
// General form: "div dst /= src"
@Override public void asm(CodeGen code, SB sb) {
- sb.p(code.reg(this)).p(" = ").p(code.reg(in(1))).p(" / ").p(code.reg(in(2)));
+ sb.p(code.reg(this)).p(" = ").p(code.reg(in(1))).p(_mod ? " % " : " / ").p(code.reg(in(2)));
}
- @Override public String comment() { return "kill rdx"; }
+ @Override public String comment() { return (_mod ? "kill rax" : "kill rdx")+", flags; zero and -1 guarded"; }
}
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java
index dc15b185..d4714953 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/node/cpus/x86_64_v2/x86_64_v2.java
@@ -4,6 +4,8 @@ import com.seaofnodes.simple.codegen.*;
import com.seaofnodes.simple.node.*;
import com.seaofnodes.simple.type.*;
import com.seaofnodes.simple.util.Utils;
+import com.seaofnodes.simple.util.Ary;
+import java.util.IdentityHashMap;
public class x86_64_v2 extends Machine {
public x86_64_v2( CodeGen code ) {}
@@ -305,6 +307,7 @@ public class x86_64_v2 extends Machine {
case GuardNode guard -> new GuardMach(guard);
case ConstantNode con -> con(con);
case DivNode div -> div.mode()==2 ? new DivFX86(div) : new DivX86(div);
+ case ModNode mod -> mod.mode()==2 ? new ModFNode(mod) : new DivX86(mod);
case EscapeNode esc -> new EscapeNode(esc);
case FunNode fun -> new FunX86(fun);
case FunPtrNode fptr -> fptr(fptr);
@@ -354,7 +357,7 @@ public class x86_64_v2 extends Machine {
return new AddFX86(add);
Node lhs = add.in(1);
Node rhs = add.in(2);
- if( lhs instanceof LoadNode ld && ld.nOuts() == 1 && ld.declaredType().log_size() >= 3)
+ if( lhs instanceof LoadNode ld && ld.declaredType().log_size() >= 3 && canFoldLoad(ld,rhs) )
return new AddMemX86(add, address(ld), ld.ptr(), idx, off, scale, 0, rhs);
// Attempt a full LEA-style break down.
// Returns one of AddX86, AddIX86, LeaX86, or LHS
@@ -430,11 +433,11 @@ public class x86_64_v2 extends Machine {
// Since cmp does not record a BOP, SetX/Jmp need to know if the CMP is swapped.
// Vs memory
- if( lhs instanceof LoadNode ld && ld.nOuts() == 1 && rhs._type.isa(ld.declaredType()) )
+ if( lhs instanceof LoadNode ld && rhs._type.isa(ld.declaredType()) && canFoldLoad(ld,rhs) )
return new CmpMemX86(bool, address(ld), ld.ptr(), idx, off, scale, imm(rhs), val, false);
// Operands swap in the encoding directly, no need for Set/Jmp to swap `bop`
- if( rhs instanceof LoadNode ld && ld.nOuts() == 1 && lhs._type.isa(ld.declaredType()) &&
+ if( rhs instanceof LoadNode ld && lhs._type.isa(ld.declaredType()) && canFoldLoad(ld,lhs) &&
(!(lhs instanceof ConstantNode con && con._con instanceof TypeInteger ti && imm32(ti.value())) ||
bool.op()=="==" || bool.op()=="!=") )
return new CmpMemX86(bool, address(ld), ld.ptr(), idx, off, scale, imm(lhs), val, true );
@@ -451,6 +454,25 @@ public class x86_64_v2 extends Machine {
return new CmpX86(bool);
}
+ // The other operand must not depend on a writer which must follow this
+ // load. Fusing them would move the read across that write (or form a
+ // scheduling cycle). Control dependencies count too, including calls.
+ private static boolean canFoldLoad(LoadNode load, Node value) {
+ if( load.nOuts()!=1 ) return false;
+ Ary<Node> writers=load.antiDeps(new Ary<>(Node.class));
+ if( writers.isEmpty() ) return true;
+ var seen=new IdentityHashMap<Node,Boolean>();
+ Ary<Node> work=new Ary<>(Node.class);
+ work.push(value);
+ while( !work.isEmpty() ) {
+ Node n=work.pop();
+ if( seen.put(n,Boolean.TRUE)!=null ) continue;
+ if( writers.find(n)!=-1 ) return false;
+ for( Node def : n._inputs ) if( def!=null ) work.push(def);
+ }
+ return true;
+ }
+
private Node con( ConstantNode con ) {
if( !con._con.isConstant() )
return ConstantNode.raw(con); // Default unknown caller inputs
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/parser/Construction.java b/chapter31/src/main/java/com/seaofnodes/simple/parser/Construction.java
index 6dec8ac1..7797cae4 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/parser/Construction.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/parser/Construction.java
@@ -56,7 +56,8 @@ import com.seaofnodes.simple.util.Ary;
* binding denotes the allocator. Private-memory Parms therefore need no
* fictitious external default or constructor-specific transfer function.
* InitView and Construct are erased by the existing TypeCheck walk. There is
- * no extra construction pass; see docs/construction-groups.md.
+ * no extra construction pass; see chapter29/docs/construction-groups.md
+ * from the repository root, and chapter29/README.md for the introduction.
*/
final class Construction {
private final Parser P;
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/parser/Expressions.java b/chapter31/src/main/java/com/seaofnodes/simple/parser/Expressions.java
index 6486aba8..ffc96f57 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/parser/Expressions.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/parser/Expressions.java
@@ -233,7 +233,7 @@ final class Expressions {
* Parse an multiplicativeExpr expression
*
* <pre>
- * multiplicativeExpr : unaryExpr (('*' | '/') unaryExpr)*
+ * multiplicativeExpr : unaryExpr (('*' | '/' | '%') unaryExpr)*
* </pre>
* @return a multiply expression {@link Node}, never {@code null}
*/
@@ -242,6 +242,7 @@ final class Expressions {
while( true ) {
if( P.match("*") ) lhs = new MulNode(lhs,null);
else if( P.match("/") ) lhs = new DivNode(lhs,null);
+ else if( P.match("%") ) lhs = new ModNode(lhs,null);
else break;
lhs.setDef(2,parseUnary());
lhs = P.peep(lhs);
@@ -341,6 +342,7 @@ final class Expressions {
case '-' -> new SubNode(lhs,rhs);
case '*' -> new MulNode(lhs,rhs);
case '/' -> new DivNode(lhs,rhs);
+ case '%' -> new ModNode(lhs,rhs);
case '|' -> new OrNode(null,lhs,rhs);
case '&' -> new AndNode(null,lhs,rhs);
case '^' -> new XorNode(P.loc(),lhs,rhs);
diff --git a/chapter31/src/main/java/com/seaofnodes/simple/parser/Lexer.java b/chapter31/src/main/java/com/seaofnodes/simple/parser/Lexer.java
index 62dd054e..8633f2be 100644
--- a/chapter31/src/main/java/com/seaofnodes/simple/parser/Lexer.java
+++ b/chapter31/src/main/java/com/seaofnodes/simple/parser/Lexer.java
@@ -325,7 +325,7 @@ public class Lexer {
//
private boolean isPunctuation(char ch) {
- return "=;[]<>()+-/*&|^".indexOf(ch) != -1;
+ return "=;[]<>()+-/*%&|^".indexOf(ch) != -1;
}
private String parsePunctuation() {
@@ -350,7 +350,7 @@ public class Lexer {
if( match(">>=" ) ) return SAR;
if( _position+2 >= _input.length ) return 0;
char ch0 = (char)_input[_position];
- if( "+-/*&|^".indexOf(ch0) == -1 ) return 0;
+ if( "+-/*%&|^".indexOf(ch0) == -1 ) return 0;
char ch1 = (char)_input[_position+1];
if( ch1 == '=' ) { _position += 2; return ch0; }
if( isIdLetter((char)_input[_position+2]) ) return 0;
diff --git a/chapter31/src/main/smp/sys.smp b/chapter31/src/main/smp/sys.smp
index 3fb8d94b..58896f33 100644
--- a/chapter31/src/main/smp/sys.smp
+++ b/chapter31/src/main/smp/sys.smp
@@ -8,7 +8,7 @@ val aryi64 = aryi64; // Variable sized array of i64
val aryu8 = aryu8; // Variable sized array of u8
val char = char; // Character utilities
val integer = integer; // Integer bounds
-val math = math; // Floating-point representation primitives
+val math = math; // Math functions, constants, and float representations
val io = io; // IO library
val gfx = gfx; // Optional pixel window (MiniFB)
val draw = draw; // Software raster drawing in Simple
diff --git a/chapter31/src/main/smp/sys/audio.md b/chapter31/src/main/smp/sys/audio.md
new file mode 100644
index 00000000..bb2ad77c
--- /dev/null
+++ b/chapter31/src/main/smp/sys/audio.md
@@ -0,0 +1,84 @@
+# Optional background audio
+
+[Chapter 31](../../../../README.md#graphics-and-sound) introduces the library.
+The Simple API is implemented in [audio.smp](audio.smp), with the native adapter
+in [simple_miniaudio.c](../../c/simple_miniaudio.c).
+
+`sys.audio` uses [miniaudio](https://github.com/mackron/miniaudio) through an
+optional native C backend. Playback runs on its own thread; the game keeps
+processing input and drawing. No Python, CMake, codec packages, or sound files
+are needed. Default builds/tests never download miniaudio or open a device.
+
+From `chapter31`:
+
+```sh
+make libs # Once while online
+make audio
+make run-graphical-tictactoe
+```
+
+The last command builds both optional backends and runs a tictactoe game with
+sounds. Accepted moves get a quiet 70ms sine boop. A player win gets a 480ms
+rising C-E-G celebration; a CPU win reverses the notes
+
+For direct execution from `chapter31`, configure both backends and launch the
+game using your shell.
+
+PowerShell:
+
+```powershell
+$env:SIMPLE_MINIFB = (Resolve-Path build/release/x86_64_v2_win64/simple_minifb.dll).Path
+$env:SIMPLE_MINIAUDIO = (Resolve-Path build/release/x86_64_v2_win64/simple_miniaudio.dll).Path
+.\build\examples\x86_64_v2_win64\TicTacToeGraphical.exe
+```
+
+Command Prompt (`cmd.exe`):
+
+```bat
+set "SIMPLE_MINIFB=%CD%\build\release\x86_64_v2_win64\simple_minifb.dll"
+set "SIMPLE_MINIAUDIO=%CD%\build\release\x86_64_v2_win64\simple_miniaudio.dll"
+.\build\examples\x86_64_v2_win64\TicTacToeGraphical.exe
+```
+
+Bash (Cygwin, using the Windows build):
+
+```bash
+export SIMPLE_MINIFB="$PWD/build/release/x86_64_v2_win64/simple_minifb.dll"
+export SIMPLE_MINIAUDIO="$PWD/build/release/x86_64_v2_win64/simple_miniaudio.dll"
+./build/examples/x86_64_v2_win64/TicTacToeGraphical.exe
+```
+
+Linux uses `libsimple_miniaudio.so` in the corresponding release directory.
+`SIMPLE_MINIAUDIO` must name the full backend path. Unset it or set it to `off`
+for silent play. An unavailable audio device returns `ERROR` and the game
+continues. Audio and graphics can be configured independently.
+
+| Operation | Meaning |
+| --- | --- |
+| `open()` | Open output and generate built-in sounds; `OK` (0) or `ERROR` (-1). Repeated open is safe. |
+| `boop()`, `win()`, `lose()` | Play a built-in cue; same as `play(BOOP/WIN/LOSE)`. |
+| `load(samples)` | Copy `i16[~]` mono PCM at `RATE` (48000Hz); return handle or `ERROR`. |
+| `play(handle)` | Start/restart, replacing the current sound. Return `OK` or `ERROR`. |
+| `stop()` | Stop playback; safe before open/after close. |
+| `playing()` | Whether samples remain to submit; final device buffering may remain. |
+| `close()` | Join the audio thread and free device/buffers; safe to repeat. |
+
+All calls belong on the main/game thread. Load custom sounds at startup:
+there are 28 custom slots, each up to ten seconds, retained until close.
+Custom handles must be reloaded after close/reopen. Signed samples range
+from -32768 to 32767; quiet effects should use much smaller amplitudes.
+Native code copies the array and never retains a Simple heap pointer or calls
+Simple from the audio thread. Playback itself neither allocates nor waits for
+the sound duration. This first interface plays one sound at a time.
+
+`audio.mk` pins miniaudio 0.11.23, cached under `lib/miniaudio-0.11.23/` by
+`make libs` (or `init`; `lib` remains a setup alias). Only these explicit
+setup targets can download dependencies. All builds, runs, and tests use local
+copies, surviving `make clean`; missing cache entries fail promptly with setup
+instructions. Windows uses the existing MinGW-w64 compiler; Linux uses GCC and
+system pthread/math/dl libraries. No audio development headers need
+installing. The upstream header includes its public-domain and MIT-0 license
+options, copied beside the backend as `miniaudio-LICENSE`. `make test-audio`
+builds the backend checks from the local cache and runs a real audio thread
+with miniaudio's silent null device; normal tests exercise the loader and game
+without hardware.
diff --git a/chapter31/src/main/smp/sys/audio.smp b/chapter31/src/main/smp/sys/audio.smp
index 89e6dfa9..5dbe63a3 100644
--- a/chapter31/src/main/smp/sys/audio.smp
+++ b/chapter31/src/main/smp/sys/audio.smp
@@ -1,4 +1,5 @@
// Optional background audio. All API calls belong on the game/main thread.
+// API and launch reference: audio.md beside this file.
int OK = 0;
int ERROR = -1;
int BOOP = 1;
diff --git a/chapter31/src/main/smp/sys/draw.smp b/chapter31/src/main/smp/sys/draw.smp
index 2a8b6117..92bf04b7 100644
--- a/chapter31/src/main/smp/sys/draw.smp
+++ b/chapter31/src/main/smp/sys/draw.smp
@@ -1,4 +1,5 @@
// Software raster drawing. No window or native calls; pixels are packed RGB (0x00RRGGBB).
+// API reference: draw/README.md.
u32 BLACK = 0x000000;
u32 WHITE = 0xffffff;
u32 RED = 0xff0000;
diff --git a/chapter31/src/main/smp/sys/draw/Canvas.smp b/chapter31/src/main/smp/sys/draw/Canvas.smp
index 9ba3514a..5ec7c9ef 100644
--- a/chapter31/src/main/smp/sys/draw/Canvas.smp
+++ b/chapter31/src/main/smp/sys/draw/Canvas.smp
@@ -1,32 +1,76 @@
struct Canvas {
- u32 width;
- u32 height;
- u32[] pixels;
+ u32 !width;
+ u32 !height;
+ u32[] !pixels;
+ // Layout coordinates are relative to the constructor's base size.
+ // A single float scale preserves circles and game geometry on resize.
+ u32 baseWidth, baseHeight;
+ f64 scale = 1.0;
+ int offsetX = 0, offsetY = 0;
new Canvas = { u32 w, u32 h ->
+ if( w > sys.integer.MAX_I32 || h > sys.integer.MAX_I32 ) libc._exit(1);
i64 count = w;
count *= h;
if( w <= 0 || h <= 0 || count > sys.integer.MAX_I32 ) libc._exit(1);
width = w;
height = h;
+ baseWidth = w;
+ baseHeight = h;
pixels = new u32[count];
};
+ // Ignore minimized windows. Return true only when a redraw is needed.
+ val resize = { u32 w, u32 h ->
+ if( w == 0 || h == 0 || (w == width && h == height) ) return false;
+ if( w > sys.integer.MAX_I32 || h > sys.integer.MAX_I32 ) libc._exit(1);
+ i64 count = w; count *= h;
+ if( count > sys.integer.MAX_I32 ) libc._exit(1);
+ // Reuse storage while dragging. Geometric growth bounds total allocation
+ // even in the current runtime, which does not yet collect old arrays.
+ if( count > pixels# ) {
+ i64 capacity = pixels#*2;
+ if( capacity < count ) capacity = count;
+ if( capacity > sys.integer.MAX_I32 ) capacity = sys.integer.MAX_I32;
+ pixels = new u32[capacity];
+ }
+ width = w; height = h;
+ f64 sx = w*1.0/baseWidth, sy = h*1.0/baseHeight;
+ scale = sx < sy ? sx : sy;
+ offsetX = (w-baseWidth*scale)/2;
+ offsetY = (h-baseHeight*scale)/2;
+ return true;
+ };
+
+ // Inverse of the drawing transform. Margins are outside the layout;
+ // reject them before integer truncation can turn a small negative into 0.
+ val localX = { int x ->
+ if( x < offsetX || x >= offsetX+baseWidth*scale ) return -1;
+ int local = (x-offsetX)/scale;
+ return local;
+ };
+ val localY = { int y ->
+ if( y < offsetY || y >= offsetY+baseHeight*scale ) return -1;
+ int local = (y-offsetY)/scale;
+ return local;
+ };
+
val clear = { u32 color ->
- for( int i = 0; i < pixels#; i++ ) pixels[i] = color;
+ i64 count = width; count *= height;
+ for( int i = 0; i < count; i++ ) pixels[i] = color;
return self;
};
val pixel = { i64 x, i64 y, u32 color ->
- if( 0 <= x < width && 0 <= y < height ) pixels[y*width+x] = color;
- return self;
+ return fillRect(x,y,1,1,color);
};
// Integer coordinates, top-left origin. Rectangle extents are half-open.
val fillRect = { i64 x, i64 y, i64 w, i64 h, u32 color ->
if( w <= 0 || h <= 0 ) return self;
- i64 right = x; right += w;
- i64 bottom = y; bottom += h;
+ i64 right = offsetX+(x+w)*scale;
+ i64 bottom = offsetY+(y+h)*scale;
+ x = offsetX+x*scale; y = offsetY+y*scale;
if( right <= 0 || bottom <= 0 || x >= width || y >= height ) return self;
int x0 = x < 0 ? 0 : x, y0 = y < 0 ? 0 : y;
int x1 = right > width ? width : right, y1 = bottom > height ? height : bottom;
@@ -55,6 +99,10 @@ struct Canvas {
};
val _circle = { i64 cx, i64 cy, int radius, int thickness, bool filled, u32 color ->
if( radius < 0 || (!filled && thickness <= 0) ) return self;
+ cx = offsetX+cx*scale; cy = offsetY+cy*scale;
+ radius *= scale;
+ thickness *= scale;
+ if( !filled && thickness < 1 ) thickness = 1;
i64 left = cx; left -= radius;
i64 top = cy; top -= radius;
i64 right = cx; right += radius;
@@ -79,6 +127,10 @@ struct Canvas {
// box is scanned. Floating distances avoid overflowing coordinate squares.
val line = { i64 x0, i64 y0, i64 x1, i64 y1, i64 thickness, u32 color ->
if( thickness <= 0 ) return self;
+ x0 = offsetX+x0*scale; y0 = offsetY+y0*scale;
+ x1 = offsetX+x1*scale; y1 = offsetY+y1*scale;
+ thickness *= scale;
+ if( thickness < 1 ) thickness = 1;
i64 pad = thickness/2+1;
i64 left = x0 < x1 ? x0 : x1; left -= pad;
i64 top = y0 < y1 ? y0 : y1; top -= pad;
diff --git a/chapter31/src/main/smp/sys/draw/README.md b/chapter31/src/main/smp/sys/draw/README.md
new file mode 100644
index 00000000..7d3bf6c8
--- /dev/null
+++ b/chapter31/src/main/smp/sys/draw/README.md
@@ -0,0 +1,124 @@
+# Drawing in Simple
+
+[Chapter 31](../../../../../README.md#graphics-and-sound) introduces the library.
+The implementation is in [Canvas.smp](Canvas.smp), [Button.smp](Button.smp),
+and the [draw module](../draw.smp).
+
+`sys.draw` draws into an ordinary `u32[]`. It has no native dependencies and
+does not open a window. `sys.gfx` presents the resulting pixels using the
+optional [MiniFB backend](../gfx.md).
+
+```simple
+val canvas = new sys.draw.Canvas(600,780);
+u32 orange = 0xe47b57;
+canvas.clear(sys.draw.WHITE);
+canvas.fillRect(20,20,180,80,orange);
+canvas.rect(20,20,180,80,3,sys.draw.BLACK);
+canvas.circle(300,200,48,8,sys.draw.BLUE);
+canvas.fillCircle(420,200,20,sys.draw.GREEN);
+canvas.line(40,320,250,440,12,orange);
+canvas.text(40,500,"YOUR TURN",4,sys.draw.BLACK);
+// After sys.gfx.open succeeds:
+sys.gfx.presentSize(canvas.pixels,canvas.width,canvas.height);
+```
+
+## Small raster API
+
+Coordinates start at the upper left; x increases rightward and y downward.
+Drawing methods return the canvas for chaining. Everything is opaque RGB;
+there is no blending, antialiasing, transform stack, or native drawing state.
+Coordinates accept `i64` so ordinary widened arithmetic can be passed directly.
+Circle radii and circle stroke widths are `int`. Use screen-sized coordinates,
+extents, and stroke widths.
+
+| Operation | Behavior |
+| --- | --- |
+| `rgb(r,g,b)` | Clamp components to 0–255 and pack RGB. `BLACK`, `WHITE`, `RED`, `GREEN`, and `BLUE` are available too. |
+| `new Canvas(width,height)` | Allocate a zero-filled pixel array. Dimensions must be positive and their product must fit a signed 32-bit index; invalid sizes exit with status 1. Allocation can still fail for lack of memory. |
+| `resize(width,height)` | Fit the original layout into new drawable dimensions; return whether they changed. Ignore zero dimensions. |
+| `localX(x)`, `localY(y)` | Convert drawable pixels to base coordinates for input; return -1 in the margins. |
+| `clear(color)` | Fill the entire canvas. |
+| `pixel(x,y,color)` | Set one pixel; ignore points outside the canvas. |
+| `fillRect(x,y,w,h,color)` | Fill a half-open rectangle: x through x+w-1, y through y+h-1. |
+| `rect(x,y,w,h,thickness,color)` | Draw an inward outline. A sufficiently wide outline fills the rectangle. |
+| `fillCircle(cx,cy,radius,color)` | Fill a circle; radius zero draws its center pixel. |
+| `circle(cx,cy,radius,thickness,color)` | Draw an inward circular outline. |
+| `line(x0,y0,x1,y1,thickness,color)` | Draw a round-ended segment. A zero-length segment draws a round dot. Thickness is its geometric diameter, sampled at integer pixel centers. |
+| `text(x,y,string,scale,color)` | Draw a 3×5 bitmap font, with one column between characters. Upper/lowercase ASCII letters, digits, spaces, and basic punctuation are supported. Newline advances six scaled pixels. Unknown characters use `?`. |
+
+Shapes clip to the canvas. Nonpositive rectangle extents, stroke widths, or
+text scale do nothing; negative circle radii do nothing. Line and circle
+coverage scans only the clipped bounding box, which is sufficient for small
+turn-based games. This is a starting raster library rather than a fast animated
+renderer. The pixel array remains available for direct drawing and inspection.
+
+The constructor sets the layout's `baseWidth` and `baseHeight`. Resizing uses
+`scale = min(width/baseWidth, height/baseHeight)` in floating point and centers
+the result with `offsetX` and `offsetY`. Sizes, offsets, glyph cells, and stroke
+widths all use this transform; circles stay circular. Positive line and circle
+strokes retain at least one drawable pixel. Existing drawing coordinates remain
+in base units, while `width`, `height`, and direct pixel indexing use the actual
+framebuffer dimensions. `clear` fills the whole framebuffer, including margins.
+At very small sizes, details smaller than a pixel naturally disappear.
+
+Canvas reuses its pixel storage and grows its capacity geometrically when needed.
+Only the first `width*height` elements are active; use `gfx.presentSize` after
+resizing. This avoids allocating on every drag event, including repeated shrink
+and grow cycles. Use `localX`/`localY` before button or game hit tests so drawing
+and input share the same scale and centering.
+
+Packed colors use hexadecimal literals (`0xRRGGBB`); `rgb(r,g,b)` remains handy
+for computed components. The font masks use leading-zero octal, with five
+digits after the prefix: each digit is one three-pixel row, top to bottom.
+For example, `A` is `025755`: rows `010`, `101`, `111`, `101`, `101`.
+The font includes all printable ASCII punctuation except `@`, `&`, and `$`,
+which use the question-mark fallback. Colons and slashes support clock and date
+labels; quotes, brackets, arithmetic signs, and other small symbols fit in 3×5.
+
+## Button widget
+
+`new sys.draw.Button(x,y,width,height,label)` creates a rectangular software
+button. It owns no window or native resources. Feed pointer coordinates and
+the held mouse-button state to `update(x,y,down)` once per event-loop iteration.
+It returns true once on release inside, provided the press began inside.
+Dragging in from outside does not activate it; releasing outside cancels.
+
+`hovered` and `pressed` expose visual state. Set `enabled=false` to cancel a
+pending press and disable activation; `label` can be changed at any time.
+`contains(x,y)` uses half-open bounds. `draw(canvas,scale,foreground,background,active)`
+paints the button and centers its 3x5 label when it fits. Colors belong to the
+caller. Keyboard shortcuts belong to the application; this small widget has
+no focus system. The [clock example](../../../../../docs/examples/Clock.smp) shows mouse activation
+and a Space shortcut in the same single-threaded loop.
+
+## Graphical tic-tac-toe
+
+From `chapter31`:
+
+```sh
+make run-graphical-tictactoe
+```
+
+Click an empty square or press **1–9**, numbered left-to-right, top-to-bottom.
+You are X; the CPU is O. It wins when possible, blocks your immediate win,
+then prefers the center, corners, and edges. The result stays visible with
+the winning line highlighted. Press **R** or **Space** to start a new game,
+or **Q**/**Escape** to quit. Restart is also available during a game.
+
+Held buttons and keys do not take repeated turns. Moving the pointer highlights
+empty cells. The canvas is redrawn after a move, restart, hover change, or resize;
+polling still processes window events and waits between polls.
+
+`make graphical-tictactoe` builds without opening a window or requiring
+MiniFB. Its output is `build/examples/x86_64_v2_win64/TicTacToeGraphical.exe`
+on Windows or `build/examples/x86_64_v2_SystemV/TicTacToeGraphical` on Linux.
+Backend discovery and explicit overrides follow [the pixel-window instructions](../gfx.md).
+Passing any argument performs a five-poll, self-closing smoke test.
+
+The original `make tictactoe` still builds the terminal game.
+The graphical game also uses optional [background audio](../audio.md): a soft
+boop for accepted moves, rising tones for a player win, and falling tones for
+a CPU win. Bad input is silent. The run target builds/configures both backends.
+`make test CLASS=DrawTest` checks raster pixels and complete game turns
+without a display. `make tests_nographics` runs the ordinary suite with
+the backend disabled.
diff --git a/chapter31/src/main/smp/sys/gfx.md b/chapter31/src/main/smp/sys/gfx.md
new file mode 100644
index 00000000..931d985f
--- /dev/null
+++ b/chapter31/src/main/smp/sys/gfx.md
@@ -0,0 +1,154 @@
+# Optional graphics
+
+[Chapter 31](../../../../README.md#graphics-and-sound) introduces the library.
+The Simple API is implemented in [gfx.smp](gfx.smp), with the window adapter in
+[simple_minifb.c](../../c/simple_minifb.c).
+
+Simple owns the pixel array and drawing code. [MiniFB](https://github.com/emoon/minifb)
+provides a window, input, and pixel presentation. The first interface is
+`sys.gfx`: one resizable window, operated on the main thread. The
+[Graphics example](../../../../docs/examples/Graphics.smp) draws a color gradient in Simple.
+The [drawing library and graphical tic-tac-toe](draw/README.md) build on this pixel
+interface. `make run-graphical-tictactoe` builds the optional backend and
+opens the game; `make graphical-tictactoe` only builds its executable.
+The game run target also builds optional [background audio](audio.md).
+
+## Default: no graphics dependency
+
+From `chapter31`, the usual `make release`, `make tests`, and `make tictactoe`
+need no MiniFB, graphics headers, OpenGL, CMake, or running display. Nothing
+downloads dependencies unless you explicitly request `make libs` or `make init`
+(`make lib` remains a setup alias). Build and run targets never use the network.
+
+`make tests_nographics` runs the entire ordinary suite with
+`SIMPLE_MINIFB=off`. This includes the missing-backend tests, which never open
+windows. It excludes the interactive `run-graphics` target.
+
+The runtime contains a small loader using the OS dynamic-library facilities.
+It does nothing until `sys.gfx.open`. Without an available backend, `open`
+prints a diagnostic to stderr and returns `sys.gfx.ERROR` (-1). Programs can
+return a nonzero status or fall back to text; the library does not terminate
+the process. Non-graphics programs ignore even a broken graphics configuration.
+
+## Build the optional backend
+
+From `chapter31`:
+
+```sh
+make libs # Once while online; fills the persistent lib/ cache.
+make graphics graphics-example
+make run-graphics
+```
+
+`libs` downloads the revision pinned in [graphics.mk](../../../../graphics.mk) into
+ignored `lib/minifb-<revision>.tar.gz` and extracts it under `lib/`.
+`graphics` builds only its C framebuffer backend from these local sources. Windows
+uses the MinGW-w64 GCC compiler (`x86_64-w64-mingw32-gcc`) and GDI; the rest of
+Simple still uses the existing Cygwin GCC. Linux uses GCC and X11 (`libx11-dev`
+on Ubuntu), including XWayland on a Wayland desktop. OpenGL, the C++ callback
+wrappers, and upstream example programs are omitted. Native Wayland and macOS
+builds are not provided here yet.
+
+Outputs:
+
+| Platform | Backend | Example |
+| --- | --- | --- |
+| Windows | `build/release/x86_64_v2_win64/simple_minifb.dll` | `build/examples/x86_64_v2_win64/Graphics.exe` |
+| Linux | `build/release/x86_64_v2_SystemV/libsimple_minifb.so` | `build/examples/x86_64_v2_SystemV/Graphics` |
+
+`MiniFB-LICENSE` is copied alongside the backend; include it when distributing
+the library. MiniFB sources remain outside the tracked Simple sources.
+The cache survives `make clean`. Editing a makefile or rebuilding a backend
+does not fetch or check GitHub. Missing dependencies fail promptly with
+instructions to run `make libs` while online.
+
+`graphics-example` alone builds the executable without requiring MiniFB. It
+also demonstrates the diagnostic and exit status 1 when graphics is absent.
+`run-graphics` builds both, sets the backend path, and opens a window. Close it
+or release Escape to exit. Passing any argument to the executable makes it
+close after five polling iterations, for a quick smoke test.
+
+To run directly from `chapter31` in PowerShell:
+
+```powershell
+$env:SIMPLE_MINIFB = (Resolve-Path build/release/x86_64_v2_win64/simple_minifb.dll).Path
+.\build\examples\x86_64_v2_win64\Graphics.exe
+```
+
+From Command Prompt (`cmd.exe`):
+
+```bat
+set "SIMPLE_MINIFB=%CD%\build\release\x86_64_v2_win64\simple_minifb.dll"
+.\build\examples\x86_64_v2_win64\Graphics.exe
+```
+
+From Bash (Cygwin, using the Windows build):
+
+```bash
+export SIMPLE_MINIFB="$PWD/build/release/x86_64_v2_win64/simple_minifb.dll"
+./build/examples/x86_64_v2_win64/Graphics.exe
+```
+
+For WSL, from the repository root:
+
+```sh
+wsl -d Ubuntu-24.04 -- bash -lc 'cd chapter31 && make graphics graphics-example CLZDIR=build/classes-linux'
+```
+
+Inside WSL, set `SIMPLE_MINIFB` to the full path of the Linux `.so`, then run
+the Linux example with a working X11 display. For an automated virtual display:
+
+```sh
+SIMPLE_MINIFB="$PWD/build/release/x86_64_v2_SystemV/libsimple_minifb.so" \
+ xvfb-run -a build/examples/x86_64_v2_SystemV/Graphics smoke
+```
+
+With no `SIMPLE_MINIFB` setting, the runtime searches beside the executable,
+then its `../../release/<ABI>` and `../release/<ABI>` directories. These cover
+the examples and test build layouts regardless of the current directory.
+It also checks the current directory, `build/release/<ABI>`, and
+`chapter31/build/release/<ABI>` relative to the current directory. Thus built
+examples such as `Clock.exe` can be launched directly without configuration.
+
+`SIMPLE_MINIFB` overrides discovery; an invalid explicit path reports an error
+without falling back. `SIMPLE_MINIFB=off` disables graphics for headless tests.
+An absent, unloadable, or incompatible backend produces a diagnostic.
+A backend that loads but cannot create a window also reports an error cleanly.
+
+## Initial interface
+
+| Operation | Meaning |
+| --- | --- |
+| `open(title,width,height)` | Open one window; returns `OK` or `ERROR`. |
+| `present(pixels)` | Present a `u32[~]` of exactly the original `width*height` pixels, packed `0x00RRGGBB`. MiniFB stretches this buffer to the window. |
+| `width()`, `height()` | Current drawable dimensions after the last event dispatch; zero when no window exists. |
+| `presentSize(pixels,width,height)` | Present the first `width*height` elements of a buffer at an explicit resolution. Dimensions must be positive and fit the array. |
+| `poll(wait)` | Process input; `true` waits up to 17ms, waking for input. |
+| `wait(timeoutMs)` | Wait for input or timeout, then process events; 0 polls, -1 waits indefinitely. |
+| `mouseX()`, `mouseY()` | Current mouse position, origin at upper left. |
+| `button(LEFT)`, `key(code)` | Current pressed state; printable keys use uppercase ASCII. |
+| `close()` | Release native window and pixel storage; safe to repeat. |
+
+`present`, `poll`, and `wait` return `OK` (0), `CLOSED` (1, normal close/Escape), or
+`ERROR` (-1). Stop polling after either terminal result and call `close`.
+The initial input API samples held state; it is not a queue of every transition.
+
+Waits may return early; values below -1 are errors. Recheck the monotonic
+clock after waking. The [time library and animation example](time/README.md) combine
+this wait with cooperative timer deadlines. Backend API version 3 adds
+resizing and explicit framebuffer dimensions; rebuild older MiniFB adapters
+with `make graphics` from the cached sources.
+
+For drawing at the new resolution, call `canvas.resize(gfx.width(),gfx.height())`
+after processing events, redraw when it returns true, and use
+`gfx.presentSize(canvas.pixels,canvas.width,canvas.height)`. Explicit buffer
+dimensions remain valid if another resize arrives while presenting. Zero-sized
+resize notifications are ignored by Canvas so minimizing retains the last layout.
+Mouse coordinates are in drawable pixels; convert them with `canvas.localX`
+and `canvas.localY` for hit testing in the [base layout](draw/README.md).
+
+MiniFB retains its last framebuffer for repaint events. The adapter copies the
+Simple array into native-owned storage before presenting; it never retains a
+Simple heap pointer. Framebuffer allocation, the copy, and window/input calls
+are the only native work here. Drawing primitives and the games can be built
+in Simple on top of this boundary.
diff --git a/chapter31/src/main/smp/sys/gfx.smp b/chapter31/src/main/smp/sys/gfx.smp
index ae203bd1..60505ac9 100644
--- a/chapter31/src/main/smp/sys/gfx.smp
+++ b/chapter31/src/main/smp/sys/gfx.smp
@@ -1,5 +1,6 @@
// Minimal pixel-window interface; drawing belongs in Simple.
-// One fixed-size window, main thread only. Pixel format is 0x00RRGGBB.
+// API and launch reference: gfx.md beside this file.
+// One resizable window, main thread only. Pixel format is 0x00RRGGBB.
// open/present/poll return OK, CLOSED (normal user close/Esc), or ERROR.
int OK = 0;
int CLOSED = 1;
@@ -9,6 +10,9 @@ int ESCAPE = 256;
{ i64 u32 u32 -> i32 } simple_gfx_open = "C";
{ i64 u32 -> i32 } simple_gfx_present = "C";
+{ i64 u32 u32 u32 -> i32 } simple_gfx_present_size = "C";
+{ u32 } simple_gfx_width = "C";
+{ u32 } simple_gfx_height = "C";
{ i32 -> i32 } simple_gfx_poll = "C";
{ i32 } simple_gfx_mouse_x = "C";
{ i32 } simple_gfx_mouse_y = "C";
@@ -31,6 +35,19 @@ val present = { u32[~] pixels ->
simple_gfx_present(ptr,pixels#);
};
+// Drawable size after the last event dispatch; zero when closed.
+val width = { -> simple_gfx_width(); };
+val height = { -> simple_gfx_height(); };
+// Explicit dimensions keep a resize arriving during presentation harmless.
+val presentSize = { u32[~] pixels, u32 width, u32 height ->
+ if( width == 0 || height == 0 || width > pixels# || height > pixels# ) return ERROR;
+ i64 count = width; count *= height;
+ if( count > pixels# ) return ERROR;
+ i64 ptr = pixels;
+ u32 size = count;
+ simple_gfx_present_size(ptr,size,width,height);
+};
+
// wait=true waits up to 17ms, waking early for input to avoid a busy loop.
val poll = { bool wait -> simple_gfx_poll(wait); };
val mouseX = { -> simple_gfx_mouse_x(); };
diff --git a/chapter31/src/main/smp/sys/math.smp b/chapter31/src/main/smp/sys/math.smp
index a5e1887c..33bb0e5f 100644
--- a/chapter31/src/main/smp/sys/math.smp
+++ b/chapter31/src/main/smp/sys/math.smp
@@ -2,7 +2,19 @@
val PI = 3.141592653589793;
val E = 2.718281828459045;
+// Native libm functions, all f64 -> f64. sin/cos take radians; exp is e^x,
+// log is the natural logarithm, and sqrt is the nonnegative square root.
+// These are ordinary C calls: results and domain/range errors (including
+// errno) follow the host libm. They are not folded or treated as pure intrinsics.
+// The standard linker already includes -lm.
+{ f64 -> f64 } sin = "C";
+{ f64 -> f64 } cos = "C";
+{ f64 -> f64 } exp = "C";
+{ f64 -> f64 } log = "C";
+{ f64 -> f64 } sqrt = "C";
+
// Fixed-semantics C bindings recognized by the compiler's intrinsic inliner.
+// See chapter31/README.md, "Math support and intrinsics", for the compiler contract.
// These preserve all 64 bits, including signed zero and NaN payloads.
// They are NOT numeric conversions (ordinary typed assignments still are).
{ f64 -> i64 } simple_f64_bits = "C";
diff --git a/chapter31/src/main/smp/sys/text.smp b/chapter31/src/main/smp/sys/text.smp
index 43698f22..77dc2190 100644
--- a/chapter31/src/main/smp/sys/text.smp
+++ b/chapter31/src/main/smp/sys/text.smp
@@ -43,7 +43,7 @@ val integer = { !aryu8 b, i64 value, i64 spec, i64 width, i64 precision ->
if( n == 0 && precision != 0 ) digits[count++] = '0';
while( n != 0 ) {
i64 q = 0, r = 0;
- if( signed ) { q = n/base; r = q*base-n; }
+ if( signed ) { q = n/base; r = -(n%base); }
else {
// Unsigned division without a u64 type. Halving first makes
// the dividend nonnegative; the remainder needs at most one fix.
diff --git a/chapter31/src/main/smp/sys/time.smp b/chapter31/src/main/smp/sys/time.smp
index a3e9b3a2..27378ffe 100644
--- a/chapter31/src/main/smp/sys/time.smp
+++ b/chapter31/src/main/smp/sys/time.smp
@@ -1,4 +1,5 @@
// Time utilities; get the current time (both nanos and millis), sleep, time zones.
+// API, formatting, and timer reference: time/README.md.
// Instants: bare i64 UTC Unix-epoch milliseconds. Durations: i64 milliseconds.
// Monotonic readings are a separate clock domain, for deadlines/elapsed time.
@@ -61,8 +62,7 @@ val remaining = { i64 deadline_ms, i64 current_ms ->
return deadline_ms-current_ms;
};
-val _mod = { i64 n, i64 unit -> n-n/unit*unit; };
-val leap = { int year -> _mod(year,4) == 0 && (_mod(year,100) != 0 || _mod(year,400) == 0); };
+val leap = { int year -> year%4 == 0 && (year%100 != 0 || year%400 == 0); };
val monthDays = { int year, int month ->
if( month < 1 || month > 12 ) return 0;
return month == 2 ? (leap(year) ? 29 : 28) :
@@ -72,7 +72,7 @@ val monthDays = { int year, int month ->
// Gregorian civil dates, expressed using 400-year eras; no per-year loops.
val _days = { i64 year, i64 month, i64 day ->
year -= month <= 2 ? 1 : 0;
- i64 era = year/400, y = year-era*400;
+ i64 era = year/400, y = year%400;
i64 mp = month+(month > 2 ? -3 : 9);
return era*_DAYS_PER_ERA+y*365+y/4-y/100+(153*mp+2)/5+day-1-_MARCH_EPOCH_DAYS;
};
@@ -91,17 +91,17 @@ val makeUTC = { int year, int month, int day, int hour, int minute, int second,
val utc = { i64 instant ->
val d = DateTime.empty();
if( instant < MIN || instant > MAX ) return d;
- i64 day = instant/DAY, rest = _mod(instant,DAY);
+ i64 day = instant/DAY, rest = instant%DAY;
if( rest < 0 ) { rest += DAY; day--; }
- i64 z = day+_MARCH_EPOCH_DAYS, era = z/_DAYS_PER_ERA, doe = z-era*_DAYS_PER_ERA;
+ i64 z = day+_MARCH_EPOCH_DAYS, era = z/_DAYS_PER_ERA, doe = z%_DAYS_PER_ERA;
i64 y = (doe-doe/(_DAYS_PER_4_YEARS-1)+doe/_DAYS_PER_CENTURY-doe/(_DAYS_PER_ERA-1))/365;
i64 doy = doe-(365*y+y/4-y/100), mp = (5*doy+2)/153;
d.day = doy-(153*mp+2)/5+1;
d.month = mp+(mp < 10 ? 3 : -9);
d.year = y+era*400+(d.month <= 2 ? 1 : 0);
- d.hour = rest/HOUR; d.minute = _mod(rest/MINUTE,60);
- d.second = _mod(rest/SECOND,60); d.millisecond = _mod(rest,SECOND);
- d.weekday = _mod(day+4,7);
+ d.hour = rest/HOUR; d.minute = rest/MINUTE%60;
+ d.second = rest/SECOND%60; d.millisecond = rest%SECOND;
+ d.weekday = (day+4)%7;
if( d.weekday < 0 ) d.weekday += 7;
return d;
};
@@ -136,13 +136,13 @@ val _format = { i64 instant, int style, bool localZone ->
if( d.year == 0 || style < 0 || style > 5 || style == 3 ) return "<invalid time>";
val b = new aryu8();
if( style == 4 ) {
- _digits(b,d.day,2).add('/'); _digits(b,d.month,2).add('/'); _digits(b,_mod(d.year,100),2);
+ _digits(b,d.day,2).add('/'); _digits(b,d.month,2).add('/'); _digits(b,d.year%100,2);
} else {
if( style == 0 ) {
_digits(b,d.year,4).add('-'); _digits(b,d.month,2).add('-'); _digits(b,d.day,2).add('T');
}
int hour = d.hour;
- if( style == 1 ) { hour = _mod(hour,12); if( hour == 0 ) hour = 12; }
+ if( style == 1 ) { hour = hour%12; if( hour == 0 ) hour = 12; }
_digits(b,hour,style == 1 ? 1 : 2).add(':'); _digits(b,d.minute,2);
if( style == 0 || style == 5 ) { b.add(':'); _digits(b,d.second,2); }
if( style == 1 ) b.addAry(d.hour < 12 ? "am" : "pm");
@@ -153,8 +153,8 @@ val _format = { i64 instant, int style, bool localZone ->
i64 offset = d.offsetSeconds;
b.add(offset < 0 ? '-' : '+');
if( offset < 0 ) offset = -offset;
- _digits(b,offset/3600,2).add(':'); _digits(b,_mod(offset/60,60),2);
- if( _mod(offset,60) != 0 ) { b.add(':'); _digits(b,_mod(offset,60),2); }
+ _digits(b,offset/3600,2).add(':'); _digits(b,offset/60%60,2);
+ if( offset%60 != 0 ) { b.add(':'); _digits(b,offset%60,2); }
}
}
}
@@ -166,7 +166,7 @@ val elapsed = { i64 ms ->
// Nonpositive arithmetic handles the minimum i64 without negating it.
if( ms < 0 ) b.add('-'); else ms = -ms;
_digits(b,-(ms/MINUTE),2).add(':');
- _digits(b,-_mod(ms/SECOND,60),2).add('.'); _digits(b,-_mod(ms,SECOND),3);
+ _digits(b,-(ms/SECOND%60),2).add('.'); _digits(b,-(ms%SECOND),3);
return text.end(b);
};
val format = { i64 instant, int style ->
diff --git a/chapter31/src/main/smp/sys/time/README.md b/chapter31/src/main/smp/sys/time/README.md
new file mode 100644
index 00000000..baa920cb
--- /dev/null
+++ b/chapter31/src/main/smp/sys/time/README.md
@@ -0,0 +1,133 @@
+# Time and single-threaded animation
+
+[Chapter 31](../../../../../README.md#time-library) introduces the library.
+The implementation is in [time.smp](../time.smp), [DateTime.smp](DateTime.smp),
+and [Timers.smp](Timers.smp).
+
+`sys.time` uses bare `i64` values: absolute instants are milliseconds since
+the Unix epoch in UTC; durations are milliseconds. Monotonic readings belong
+to a separate clock domain. Never subtract a wall-clock reading from a
+monotonic deadline.
+
+## Clocks and waits
+
+| Call | Result |
+| --- | --- |
+| `time.now()` | Unix-epoch milliseconds; may jump when the system clock changes. |
+| `time.monotonic()` | Monotonic milliseconds for elapsed time and deadlines. |
+| `time.nanoTime()` | Monotonic nanoseconds, with the clock's available resolution. |
+| `time.sleep(duration_ms)` | Sleep for a nonnegative duration. |
+| `time.sleepUntil(deadline_ms)` | Wait for a monotonic millisecond deadline; returns immediately if past. |
+| `time.remaining(deadline_ms, current_ms)` | Nonnegative difference, saturating on overflow. |
+
+Clock errors return `-1`; sleeps return zero on success or `-1` on error,
+with `sys.libc.errno()` available. Interrupted sleeps resume rather than
+returning early. Wakeup times are approximate, and these calls do not wake a
+suspended laptop. Sleeping blocks the one Simple execution thread; use
+`gfx.wait` when window input must remain responsive.
+
+`seconds(n)`, `minutes(n)`, `hours(n)`, and `days(n)` convert signed counts
+to milliseconds. `toSeconds(ms)`, `toMinutes(ms)`, `toHours(ms)`, and
+`toDays(ms)` truncate toward zero. A duration day is exactly 24 hours,
+independent of daylight saving. `toNanos(ms)` and `fromNanos(ns)` convert
+between millisecond and nanosecond units. Multiplication overflow returns
+`-1`. Constants `SECOND`, `MINUTE`, `HOUR`, and `DAY` are also available,
+defined as `1000`, `60*SECOND`, `60*MINUTE`, and `24*HOUR` respectively.
+`NANOS_PER_MS` is `1000*1000`. Overflow checks use the shared
+`sys.integer.MIN_I64` and `MAX_I64` bounds; `MAX_I32` and `MAX_U32` in that
+module also describe the library's array and timer-ID limits.
+
+## String interpolation
+
+Time formatting is built into the existing string interpolation syntax:
+
+| Format | Example | Named style |
+| --- | --- | --- |
+| `%t(instant)` or `%tF(instant)` | `2026-11-12T00:34:05.123Z` | `time.ISO` |
+| `%tr(instant)` | `12:34am` | `time.CLOCK12` |
+| `%tR(instant)` | `00:34` | `time.CLOCK24` |
+| `%tT(instant)` | `00:34:05` | `time.CLOCK24_SECONDS` |
+| `%tD(instant)` | `12/11/26` | `time.DATE` |
+| `%tM(duration)` | `02:03.456` | `time.ELAPSED` |
+
+For example, `"UTC %tR(sys.time.now())"`. Width and left alignment work as
+for strings: `%30t(instant)` and `%-30t(instant)`. Precision and numeric flags
+are rejected. `%tM` formats a duration, with total minutes rather than wrapping
+at an hour; negative durations keep their sign.
+
+Interpolation uses UTC, making its output stable across machines.
+`time.format(instant, style)` is the equivalent library call;
+`time.formatLocal(instant, style)` uses the system's local zone. Local ISO
+output includes a numeric offset instead of `Z` when nonzero, retaining
+offset seconds for historical zones. Invalid calendar values/styles produce
+`<invalid time>`. The ISO form retains all millisecond bits within the supported
+calendar range; short formats intentionally omit information.
+
+## Calendar values and absolute parsing
+
+`time.utc(instant)` and `time.local(instant)` return a `DateTime` with fields
+`year`, `month`, `day`, `hour`, `minute`, `second`, `millisecond`, `weekday`
+(Sunday = 0), `offsetSeconds` (east of UTC), and `daylight`. A zero year means
+conversion failed. `time.zoneName(instant)` returns the local abbreviation or
+an empty string on error. Local conversion uses the operating system's zone
+rules, including DST at that instant; no time-zone database is downloaded.
+
+`time.makeUTC(year, month, day, hour, minute, second, millisecond)` validates
+and constructs an instant, returning `-1` on invalid fields. `time.valid(...)`,
+`time.leap(year)`, and `time.monthDays(year, month)` support calendar checks.
+Calendar conversion supports Gregorian years 1 through 9999, bounded by
+`time.MIN` and `time.MAX`, and rejects leap seconds.
+
+`time.parse(text)` accepts strict absolute ISO text:
+`YYYY-MM-DDTHH:mm:ss[.SSS]Z` or the same with an explicit `+HH:MM`/`-HH:MM`
+offset (optionally with `:SS`). Fractions have exactly three digits. No relative
+time parsing, implicit local zone, locale-dependent parsing, or named-zone
+conversion is provided. Offsets must have hours 00–23 and minutes/seconds 00–59.
+Invalid text or an out-of-range result returns `-1`. By design, this sentinel
+is indistinguishable from the valid instant `1969-12-31T23:59:59.999Z`;
+formatting and calendar conversion still support that instant.
+
+## Cooperative timers
+
+Create `val timers = new sys.time.Timers();` on the game thread:
+
+Timer IDs are `u32`, with `0` reserved for registration failure or no timer due.
+Deadlines, delays, and periods remain `i64` milliseconds; their parameter,
+field, and local names end in `_ms` to distinguish them from IDs.
+
+| Operation | Meaning |
+| --- | --- |
+| `after(delay_ms)` | Register a one-shot timer; return its positive `u32` ID, or `0`. |
+| `every(period_ms)` | Register a repeating timer; period must be positive. Returns a `u32` ID, or `0`. |
+| `afterAt(current_ms, delay_ms)`, `everyAt(current_ms, period_ms)` | Supply a monotonic reading explicitly, useful for deterministic tests. |
+| `cancel(id)` | Remove a timer; return whether it was present. |
+| `nextDeadline()` | Earliest monotonic deadline, or `-1` if empty. |
+| `poll(current_ms)` | Return the next due `u32` ID, or `0` if none. |
+
+Poll repeatedly to drain due timers. Deadlines order delivery, then registration
+ID breaks ties. Repeating timers advance from their previous deadline, skipping
+missed ticks to the first future deadline rather than drifting or replaying a
+backlog. Deadline overflow rejects registration or cancels a repeating timer.
+IDs are never reused within a collection; registration fails once all nonzero
+`u32` IDs have been issued.
+There are no callbacks or timer threads: the caller handles each returned ID.
+
+`gfx.wait(timeout_ms)` processes events after waiting for input or a timeout:
+zero polls, `-1` waits indefinitely, values below `-1` fail. It returns the same
+`OK`, `CLOSED`, or `ERROR` statuses as `gfx.poll`, and may wake early. Re-read the
+monotonic clock after each wake. This allows one thread to handle timers,
+input, simulation, and drawing without busy waiting.
+
+The [digital and analog clock example](../../../../../docs/examples/Clock.smp) combines these pieces. From
+the repository root, with graphics dependencies already cached:
+
+```sh
+make -C chapter31 clock-example # Build without opening a window.
+make -C chapter31 run-clock # Build the backend and run.
+```
+
+Click the button or press Space to switch between green seven-segment digits
+and an analog dial with smoothly moving hands. Both display system-local time;
+Q/Escape exits. Passing any argument directly to the executable closes it after
+ten frames, switching faces halfway through. Hands are computed from the current
+time, so delayed frames do not create a simulation catch-up backlog.
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java
index b29c9706..2299bd17 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ArithNodeTest.java
@@ -85,6 +85,7 @@ public class ArithNodeTest {
ops.add(new SubNode(lhs,rhs,mode));
ops.add(new MulNode(lhs,rhs,mode));
ops.add(new DivNode(lhs,rhs,mode));
+ ops.add(new ModNode(lhs,rhs,mode));
}
ops.add(new AndNode(null,lhs,rhs));
ops.add(new OrNode(null,lhs,rhs));
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java b/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java
index 7f3e56d4..f374d397 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/BreakoutTest.java
@@ -191,7 +191,7 @@ public class BreakoutTest {
g._serve();
// Drive through every brick's front, bottom row first.
for( int i=COLS*ROWS-1; i>=0; i-- ) {
- g.x=LEFT+20.0+(i-i/COLS*COLS)*BRICK_DX;
+ g.x=LEFT+20.0+(i%COLS)*BRICK_DX;
g.y=BRICK_TOP+1.0+(i/COLS)*BRICK_DY+BRICK_H+RADIUS;
g.dx=0.0; g.dy=-1.0;
g._tick(0);
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java b/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java
index 1ca161cf..2af3b03e 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/DrawTest.java
@@ -3,19 +3,51 @@ package com.seaofnodes.simple;
import java.nio.file.Files;
import java.nio.file.Path;
import org.junit.Test;
-import com.seaofnodes.simple.codegen.CodeGen;
-import com.seaofnodes.simple.type.TypeInteger;
-import com.seaofnodes.simple.util.Ary;
-import static org.junit.Assert.*;
// Native raster and game checks; no backend or display is needed.
public class DrawTest {
+ @Test public void resizedLayoutAndInput() throws Exception {
+ String game=Files.readString(Path.of("docs/examples/TicTacToeGraphical.smp"))
+ .replace("val main =","val _windowMain =");
+ TestC.runSYS(game+"""
+ val main={ ->
+ val c=new sys.draw.Canvas(600,780);
+ val original=c.pixels;
+ val board=new u8[9]; _reset(board);
+ // Half size with horizontal margins: board remains square.
+ if( !c.resize(500,390) || c.scale!=0.5 || c.offsetX!=100 || c.offsetY!=0 ) return 1;
+ if( c.pixels!=original ) return 13;
+ _draw(c,board,4);
+ if( c.pixels[84*500+124]!=0x35535a || c.pixels[0]!=0x142e36 ) return 2;
+ if( _square(c.localX(250),c.localY(210))!=4 || c.localX(99)!=-1 ) return 3;
+ if( c.localX(400)!=-1 || c.localY(390)!=-1 ) return 4;
+ // Noninteger scale, taller aspect ratio, and scaled button hit box.
+ val b=new sys.draw.Button(48,168,168,168,"GO");
+ if( !c.resize(750,1100) || c.scale!=1.25 || c.offsetY!=62 ) return 5;
+ val grown=c.pixels;
+ if( b.update(c.localX(100),c.localY(300),true) ) return 6;
+ if( !b.update(c.localX(100),c.localY(300),false) ) return 7;
+ c.clear(0).fillCircle(300,400,40,9).text(48,34,"GO",3,7);
+ if( c.pixels[562*750+425]!=9 || c.pixels[612*750+375]!=9 ) return 8;
+ if( c.pixels[562*750+426]!=0 || c.pixels[613*750+375]!=0 ) return 9;
+ // Minimize and repeated sizes retain the last usable buffer.
+ if( c.resize(0,0) || c.resize(750,1100) || c.width!=750 ) return 10;
+ if( !c.resize(1,1) ) return 11;
+ _draw(c,board,4);
+ if( !c.resize(600,780) || c.scale!=1.0 || c.offsetX!=0 || c.offsetY!=0 ) return 12;
+ if( c.pixels!=grown ) return 14;
+ return 0;
+ };
+ ""","drawResize","",-1);
+ }
+
@Test public void nativeClockCoordinates() throws Exception {
String clock=Files.readString(Path.of("docs/examples/Clock.smp"))
.replace("val main =","val _windowMain =");
StringBuilder source=new StringBuilder(clock+"""
val _check_noInline={ f64 turn, int expectedX, int expectedY ->
- int x=360+_sin(turn)*128, y=232-_sin(turn+0.25)*128;
+ f64 angle=turn*2*sys.math.PI;
+ int x=360+sys.math.sin(angle)*128, y=232-sys.math.cos(angle)*128;
if( x<expectedX-1 || x>expectedX+1 || y<expectedY-1 || y>expectedY+1 ) {
sys.io.p("turn %f(turn): %(x),%(y) expected %(expectedX),%(expectedY)\\n");
return 1;
@@ -26,7 +58,7 @@ public class DrawTest {
""");
for(int i=0;i<=60;i++) {
double turn=i/60.0;
- int x=(int)(360+clockSine(turn)*128), y=(int)(232-clockSine(turn+0.25)*128);
+ int x=(int)(360+Math.sin(turn*2*Math.PI)*128), y=(int)(232-Math.cos(turn*2*Math.PI)*128);
source.append("if(_check_noInline(").append(turn).append(',').append(x).append(',').append(y)
.append(")!=0) return 1;");
}
@@ -34,14 +66,6 @@ public class DrawTest {
TestC.runSYS(source.toString(),"clockCoordinates","",-1);
}
- private static double clockSine(double turn) {
- turn-=(long)turn;
- boolean negative=turn>0.5;
- double x=(negative ? turn-0.5 : turn)*6.283185307179586;
- double product=x*(3.141592653589793-x);
- return (negative ? -16.0 : 16.0)*product/(49.34802200544679-4*product);
- }
-
@Test public void nativeAnalogSweep() throws Exception {
String clock=Files.readString(Path.of("docs/examples/Clock.smp"))
.replace("val main =","val _windowMain =");
@@ -69,7 +93,7 @@ public class DrawTest {
""");
for(int millis:new int[]{0,500,7500,15000,30000,45000,59500}) {
double turn=millis/60000.0;
- int x=(int)(360+clockSine(turn)*128), y=(int)(232-clockSine(turn+0.25)*128);
+ int x=(int)(360+Math.sin(turn*2*Math.PI)*128), y=(int)(232-Math.cos(turn*2*Math.PI)*128);
source.append("if(_renderCheck_noInline(").append(millis/1000).append(',').append(millis%1000)
.append(',').append(x).append(',').append(y).append(")!=0) return 1;");
}
@@ -103,7 +127,7 @@ public class DrawTest {
@Test public void clockFacesWithoutWindow() throws Exception {
String clock=Files.readString(Path.of("docs/examples/Clock.smp"))
.replace("val main =","val _windowMain =");
- CodeGen code=new CodeGen(null,null,new Ary<>(new String[]{TestC.RELEASE_SYS_DIR}),"ClockRaster",clock+"""
+ TestC.runSYS(clock+"""
val main={ ->
val c=new sys.draw.Canvas(720,540);
_digit(c,10,10,8);
@@ -114,12 +138,9 @@ public class DrawTest {
if( c.pixels[214*720+254]!=GREEN || c.pixels[262*720+470]!=GREEN ) return 3;
c.clear(BACKGROUND); _analog(c,3,0,0,0);
if( c.pixels[232*720+430]!=GREEN || c.pixels[160*720+360]!=0xc3ffcb || c.pixels[232*720+360]!=GREEN ) return 4;
- if( _sin(0.25)<0.999 || _sin(0.75)>-0.999 || _sin(1.0)!=0.0 ) return 5;
return 0;
};
- return main();
- """,126L,true,TypeInteger.BOT).driver(CodeGen.Phase.TypeCheck);
- assertEquals("0",Eval2.eval(code,0,3000000));
+ ""","clockRaster","",-1);
}
@Test public void rectanglesAndColors() throws Exception {
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java b/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java
index eef05f93..d6d97ef1 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/Eval2.java
@@ -313,6 +313,9 @@ public abstract class Eval2 {
case DivNode div -> div.mode()==1
? (Object)(x(div.in(2))==0 ? 0L : x(div.in(1)) / x(div.in(2)))
: (Object)((d(div.in(2))==0 ? 0D : d(div.in(1))) / d(div.in(2)));
+ case ModNode mod -> mod.mode()==1
+ ? (Object)(x(mod.in(2))==0 ? 0L : x(mod.in(1)) % x(mod.in(2)))
+ : (Object)(d(mod.in(1)) % d(mod.in(2)));
case EscapeNode esc -> esc(esc);
case FunPtrNode fptr -> con(fptr._con);
case LoadNode ld -> load(ld);
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java b/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
index 110a6a38..3b4b9e31 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/GraphicsTest.java
@@ -32,6 +32,7 @@ public class GraphicsTest {
private static String run(String exe, String backend, int exit, Path cwd) throws Exception {
ProcessBuilder pb = new ProcessBuilder(Path.of(exe).toAbsolutePath().toString()).redirectErrorStream(true);
+ pb.environment().put("SIMPLE_MINIAUDIO","off");
if (cwd!=null) pb.directory(cwd.toFile());
if( backend == null ) pb.environment().remove("SIMPLE_MINIFB");
else pb.environment().put("SIMPLE_MINIFB",backend);
@@ -68,9 +69,12 @@ public class GraphicsTest {
static int32_t poll_events(int32_t n) { return 0; }
static int32_t position(void) { return 0; }
static int32_t wait_events(int64_t n) { return 0; }
+ static uint32_t size(void) { return 0; }
+ static int32_t present_size(const uint32_t *p,uint32_t n,uint32_t w,uint32_t h) { return 0; }
static void close_window(void) {}
static const struct simple_graphics_api api={SIMPLE_GRAPHICS_VERSION,
- open_window,present,poll_events,position,position,poll_events,poll_events,close_window,wait_events};
+ open_window,present,poll_events,position,position,poll_events,poll_events,close_window,wait_events,
+ size,size,present_size};
const struct simple_graphics_api *simple_minifb_api(void) { return &api; }
""");
Path mock=root.resolve(name);
@@ -150,9 +154,15 @@ public class GraphicsTest {
(k=='R' && (frames==8 || frames==9));
}
static int32_t wait_events(int64_t ms) { usleep(ms*1000); return 0; }
+ static uint32_t width(void) { return 1008; }
+ static uint32_t height(void) { return 760; }
+ static int32_t present_size(const uint32_t *p,uint32_t n,uint32_t w,uint32_t h) {
+ return w==1008 && h==760 ? present(p,n) : -1;
+ }
static void close_window(void) {}
static const struct simple_graphics_api api={SIMPLE_GRAPHICS_VERSION,
- open_window,present,poll_events,mouse_x,mouse_y,poll_events,key,close_window,wait_events};
+ open_window,present,poll_events,mouse_x,mouse_y,poll_events,key,close_window,wait_events,
+ width,height,present_size};
const struct simple_graphics_api *simple_minifb_api(void) { return &api; }
""");
TestC.exec(30,"gcc","-shared","-fPIC","-Isrc/main/c",source.toString(),"-o",library.toString());
@@ -174,6 +184,50 @@ public class GraphicsTest {
assertTrue(output,output.contains("cannot load MiniFB backend"));
}
+ @Test public void demosResizeWithoutDisplay() throws Exception {
+ Path source=Path.of("build/objs/graphics_resize.c");
+ Path library=Path.of("build/objs/graphics_resize"+(TestC.OS.startsWith("Windows") ? ".dll" : ".so"));
+ Files.writeString(source,"""
+ #include "simple_graphics.h"
+ #include <stdio.h>
+ #include <unistd.h>
+ static unsigned step, seen, base_w, base_h;
+ static uint32_t width(void) {
+ return step==1 ? base_w/2 : step==2 ? base_w+123 : step==3 ? 1 : step==4 ? 0 : base_w;
+ }
+ static uint32_t height(void) {
+ return step==1 ? base_h/2 : step==2 ? base_h/2+17 : step==3 ? 1 : step==4 ? 0 : base_h;
+ }
+ static int32_t open_window(const char *s,uint32_t w,uint32_t h) {
+ base_w=w; base_h=h; return 0;
+ }
+ static int32_t present_size(const uint32_t *p,uint32_t n,uint32_t w,uint32_t h) {
+ if(!p || n!=(uint64_t)w*h || (step!=4 && (w!=width() || h!=height()))) return -1;
+ seen |= 1u<<step;
+ return 0;
+ }
+ static int32_t present(const uint32_t *p,uint32_t n) { return -1; }
+ static int32_t wait_events(int64_t ms) {
+ usleep(35000);
+ if(++step<6) return 0;
+ // Minimized windows need not repaint; every usable size must.
+ if((seen & 46)!=46) { printf("missing resize frames: %u\\n",seen); return -1; }
+ puts("resize passed"); return 1;
+ }
+ static int32_t poll_events(int32_t n) { return wait_events(n); }
+ static int32_t position(void) { return 0; }
+ static int32_t key(int32_t n) { return 0; }
+ static void close_window(void) {}
+ static const struct simple_graphics_api api={SIMPLE_GRAPHICS_VERSION,
+ open_window,present,poll_events,position,position,key,key,close_window,wait_events,
+ width,height,present_size};
+ const struct simple_graphics_api *simple_minifb_api(void) { return &api; }
+ """);
+ TestC.exec(30,"gcc","-shared","-fPIC","-Isrc/main/c",source.toString(),"-o",library.toString());
+ for(String exe:new String[]{graphics,clock,game,breakout})
+ assertTrue(exe,run(exe,library.toAbsolutePath().toString(),0).contains("resize passed"));
+ }
+
@Test public void textIgnoresGraphicsConfiguration() throws Exception {
assertEquals("text still works\n",run(text,"off",0));
assertEquals("text still works\n",run(text,"no-such-backend",0));
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/MathTest.java b/chapter31/src/test/java/com/seaofnodes/simple/MathTest.java
new file mode 100644
index 00000000..e19341b7
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/MathTest.java
@@ -0,0 +1,79 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+public class MathTest {
+ @Test public void nativeValues() throws Exception {
+ TestC.runSYS("""
+ val near={ f64 x, f64 y -> x==x && x-y<1e-12 && y-x<1e-12; };
+ val main={ ->
+ val angles=new f64[~]{-sys.math.PI/2,0.0,sys.math.PI/6,sys.math.PI/2};
+ val sines=new f64[~]{-1.0,0.0,0.5,1.0};
+ val cosines=new f64[~]{0.0,1.0,0.8660254037844386,0.0};
+ for(int i=0;i<angles#;i++) {
+ if(!near(sys.math.sin(angles[i]),sines[i])) return 1;
+ if(!near(sys.math.cos(angles[i]),cosines[i])) return 2;
+ }
+ if(!near(sys.math.exp(1.0),sys.math.E)) return 3;
+ if(!near(sys.math.log(sys.math.E),1.0)) return 4;
+ if(!near(sys.math.sqrt(2.0),1.4142135623730951)) return 5;
+ if(!near(sys.math.log(sys.math.exp(-3.5)),-3.5)) return 6;
+ if(sys.math.sqrt(9.0)!=3.0) return 7;
+ if(sys.math.exp(0.0)!=1.0 || sys.math.log(1.0)!=0.0) return 8;
+ return 0;
+ };
+ ""","mathValues","",-1);
+ }
+
+ @Test public void nativeSpecialValues() throws Exception {
+ TestC.runSYS("""
+ val nan={ f64 x -> x!=x; };
+ val main={ ->
+ f64 inf=sys.math.f64FromBits(0x7ff0000000000000);
+ f64 qnan=sys.math.f64FromBits(0x7ff8000000000001);
+ if(!nan(sys.math.sin(inf)) || !nan(sys.math.cos(inf))) return 1;
+ if(!nan(sys.math.log(-1.0)) || !nan(sys.math.sqrt(-1.0))) return 2;
+ if(sys.math.log(0.0)!=-inf || sys.math.log(inf)!=inf) return 3;
+ if(sys.math.exp(inf)!=inf || sys.math.exp(-inf)!=0.0) return 4;
+ if(sys.math.sqrt(inf)!=inf) return 5;
+ if(sys.math.f64Bits(sys.math.sin(-0.0))!=sys.integer.MIN_I64) return 6;
+ if(sys.math.f64Bits(sys.math.sqrt(-0.0))!=sys.integer.MIN_I64) return 7;
+ if(sys.math.cos(-0.0)!=1.0) return 8;
+ if(!nan(sys.math.sin(qnan)) || !nan(sys.math.cos(qnan))) return 9;
+ if(!nan(sys.math.exp(qnan)) || !nan(sys.math.log(qnan)) ||
+ !nan(sys.math.sqrt(qnan))) return 10;
+ if(sys.math.exp(1000.0)!=inf || sys.math.exp(-1000.0)!=0.0) return 11;
+ return 0;
+ };
+ ""","mathSpecial","",-1);
+ }
+
+ @Test public void indirectBindings() throws Exception {
+ TestC.runSYS("""
+ val apply_noInline={ { f64 -> f64 } f, f64 x -> f(x); };
+ val main={ ->
+ if(apply_noInline(sys.math.sin,0.0)!=0.0) return 1;
+ if(apply_noInline(sys.math.cos,0.0)!=1.0) return 2;
+ if(apply_noInline(sys.math.exp,0.0)!=1.0) return 3;
+ if(apply_noInline(sys.math.log,1.0)!=0.0) return 4;
+ if(apply_noInline(sys.math.sqrt,9.0)!=3.0) return 5;
+ return 0;
+ };
+ ""","mathIndirect","",-1);
+ }
+
+ @Test public void allBackends() {
+ // Load just math from source so each backend selects its own C ABI.
+ String source="""
+ f64 x=arg;
+ return math.sin(x)+math.cos(x)+math.exp(x)+
+ math.log(x)+math.sqrt(x);
+ """;
+ for(String cpu:new String[]{"x86_64_v2","arm","riscv"})
+ new CheckedCodeGen("src/main/smp/sys",null,null,"MathCalls",source,126,true,TypeInteger.BOT)
+ .driver(CodeGen.Phase.Encoding,cpu,"SystemV");
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/ModTest.java b/chapter31/src/test/java/com/seaofnodes/simple/ModTest.java
new file mode 100644
index 00000000..7f79599d
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/ModTest.java
@@ -0,0 +1,201 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.isa.eval.EvalArm64;
+import com.seaofnodes.isa.eval.EvalRisc5;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.util.Ary;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ModTest {
+ private static String literal(long x) {
+ return x==Long.MIN_VALUE ? "(-9223372036854775807-1)" : Long.toString(x);
+ }
+ @Test public void integers() {
+ long[] values={Long.MIN_VALUE,-17,-1,0,1,17,Long.MAX_VALUE};
+ long[] divisors={Long.MIN_VALUE,-5,-1,0,1,5,Long.MAX_VALUE};
+ for( long y : divisors ) {
+ for( long x : values ) {
+ CodeGen code=new CodeGen("return arg%"+literal(y)+";");
+ String expected=Long.toString(y==0 ? 0 : x%y);
+ try {
+ assertEquals(x+"%"+y,expected,Eval2.eval(code,x));
+ assertEquals(expected,Eval2.eval(new CodeGen("return "+literal(x)+"%"+literal(y)+";"),0));
+ } catch(Throwable e) { throw new AssertionError(x+"%"+y,e); }
+ }
+ }
+ }
+ @Test public void precedenceAndIdentifiers() {
+ assertEquals("6",Eval2.eval(new CodeGen("return 20%6*3;"),0));
+ assertEquals("2",Eval2.eval(new CodeGen("return 20/3%4;"),0));
+ assertEquals("21",Eval2.eval(new CodeGen("int mod=20; return mod+7%3;"),0));
+ }
+ @Test public void compoundAssignment() {
+ assertEquals("-2",Eval2.eval(new CodeGen("int x=arg; x %= 5; return x;"),-17));
+ assertEquals("0",Eval2.eval(new CodeGen("int x=17; x %= arg; return x;"),0));
+ assertEquals("1.5",Eval2.eval(new CodeGen("f64 x=7.5; x %= 2; return x;"),0));
+ assertEquals("21",Eval2.eval(new CodeGen("""
+ val a=new int[1]; a[0]=17;
+ int i=0; a[i++] %= 5;
+ return a[0]*10+i;
+ """),0));
+ }
+ @Test public void floats() {
+ for( double y : new double[]{-5.5,-1.0,0.0,1.0,5.5} ) {
+ CodeGen code=new CodeGen("return (arg+0.0)%"+y+";");
+ for( long x : new long[]{-17,-1,0,1,17} )
+ assertEquals(Double.isNaN(x%y) ? "Double.NaN" : Double.toString(x%y),Eval2.eval(code,x));
+ }
+ assertEquals("-0.0",Eval2.eval(new CodeGen("return -10.0%5.0;"),0));
+ assertEquals("1.5",Eval2.eval(new CodeGen("return 7.5%2;"),0));
+ }
+ @Test public void zeroAndDeadBranches() {
+ assertEquals("0",Eval2.eval(new CodeGen("return 1%arg;"),0));
+ assertEquals("0",Eval2.eval(new CodeGen("return 1%0;"),0));
+ CodeGen discarded=new CodeGen("1%arg; return 42;").driver(CodeGen.Phase.TypeCheck);
+ assertNull(discarded._stop.walk(n -> n instanceof ModNode || n instanceof CallNode ? n : null));
+ assertEquals("42",Eval2.eval(discarded,0));
+ CodeGen common=new CodeGen("return (arg%7)-(arg%7);").driver(CodeGen.Phase.TypeCheck);
+ assertNull(common._stop.walk(n -> n instanceof ModNode || n instanceof CallNode ? n : null));
+ assertEquals("0",Eval2.eval(common,17));
+ assertEquals("42",Eval2.eval(new CodeGen("if(arg) return 1%0; return 42;"),0));
+ assertEquals("42",Eval2.eval(new CodeGen("if(false) return 1%0; return 42;"),0));
+ }
+ @Test public void operandEffects() {
+ assertEquals("709",Eval2.eval(new CodeGen("""
+ int x=7;
+ int r=x++%++x;
+ return r*100+x;
+ """),0));
+ assertEquals("42",Eval2.eval(new CodeGen("""
+ val a=new int[1];
+ val next={ int[] a -> a[0]++; return a[0]+10; };
+ int r=next(a)%next(a);
+ return r*2+a[0]*10;
+ """),0));
+ }
+ @Test public void loopsAndRecursiveModes() {
+ String source="""
+ int sum=0;
+ for(int i=0;i<arg;i++) sum=sum+(i+1)%5;
+ return sum;
+ """;
+ assertEquals("40",Eval2.eval(new CodeGen(source),20));
+ assertEquals("41",Eval2.eval(new CodeGen(source),21));
+ assertEquals("1.5",Eval2.eval(new CodeGen("""
+ val f={ i64 n -> n==0 ? 7.5 : f(n-1)%2; };
+ return f(arg);
+ """),3));
+ }
+ @Test public void typeErrors() {
+ for( String source : new String[]{"return \"abc\"%2;", "return 2%new int[1];"} ) {
+ try {
+ new CodeGen(source).driver(CodeGen.Phase.TypeCheck);
+ fail("% needs numeric operands: "+source);
+ } catch(RuntimeException expected) {
+ assertTrue(expected.getMessage(),expected.getMessage().startsWith("Cannot"));
+ }
+ }
+ }
+ @Test public void allBackends() {
+ for( String cpu : new String[]{"x86_64_v2","arm","riscv"} )
+ new CheckedCodeGen("return arg%7 + (arg+0.5)%2.5;")
+ .driver(CodeGen.Phase.Encoding,cpu,"SystemV");
+ }
+ @Test public void nativeRemainders() throws Exception {
+ TestC.runSYS("""
+ val rem_noInline={ i64 x,i64 y -> x%y; };
+ val frem_noInline={ f64 x,f64 y -> x%y; };
+ val mixed_noInline={ f64 x,f64 y,i64 i -> x*13+(x%y)+y*17+i; };
+ val main={ ->
+ if(rem_noInline(-17,5)!=-2) return 1;
+ if(rem_noInline(17,-5)!=2) return 2;
+ if(rem_noInline(sys.integer.MIN_I64,-1)!=0) return 3;
+ if(rem_noInline(sys.integer.MIN_I64,3)!=-2) return 4;
+ if(frem_noInline(-7.5,2.0)!=-1.5) return 5;
+ if(sys.math.f64Bits(frem_noInline(-10.0,5.0))!=sys.integer.MIN_I64) return 6;
+ sys.libc.set_errno(123);
+ f64 nan=frem_noInline(1.0,0.0);
+ if(nan==nan) return 7;
+ if(sys.libc.errno()!=123) return 8;
+ if(mixed_noInline(7.5,2.0,31)!=164.0) return 9;
+ return 0;
+ };
+ ""","modNative","",-1);
+ }
+ @Test public void importedRemainders() throws Exception {
+ Path dir=Files.createTempDirectory(Path.of("build/objs"),"mod-import-");
+ new CodeGen(null,dir.toString(),null,"Remainders","val rem_noInline={ i64 x -> x%7; };",126,true,TypeInteger.BOT)
+ .driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,false,false);
+ var paths=new Ary<>(new String[]{dir.toString()});
+ CodeGen client=new CodeGen(null,dir.toString(),paths,"Client","return Remainders.rem_noInline(arg);",126,true,TypeInteger.BOT);
+ assertEquals("-3",Eval2.eval(client,-17));
+ }
+ @Test public void nativeDivisionAndRemainderEdges() throws Exception {
+ TestC.runSYS(integerEdges(),"modDivEdges","",-1);
+ }
+ @Test public void emulatedDivisionAndRemainderEdges() throws Exception {
+ long[] values={Long.MIN_VALUE,Long.MIN_VALUE+1,-17,-1,0,1,17,Long.MAX_VALUE};
+ for( String op : new String[]{"%","/"} ) {
+ String source="val main={ i64 x,i64 y -> x "+op+" y; };";
+ EvalArm64 image=TestArm64.build("main",source,0,-1,false);
+ for( long x : values ) for( long y : values ) {
+ EvalArm64 arm=new EvalArm64(image._buf,1<<16);
+ arm._pc=image._pc;
+ arm.regs[0]=x; arm.regs[1]=y;
+ assertEquals(0,arm.step(1000));
+ assertEquals(x+" "+op+" "+y,y==0 ? 0 : op.equals("%") ? x%y : x/y,arm.regs[0]);
+ }
+ // The shared RISC-V emulator's DIV/REM still operate on 32-bit values.
+ EvalRisc5 rimage=TestRisc5.build(source,"main",0,-1,false);
+ for( long x : new long[]{-17,-1,0,1,17} ) for( long y : new long[]{-17,-1,0,1,17} ) {
+ EvalRisc5 riscv=new EvalRisc5(rimage._buf,1<<16);
+ riscv._pc=rimage._pc;
+ riscv.regs[10]=x; riscv.regs[11]=y;
+ assertEquals(0,riscv.step(1000));
+ assertEquals(x+" "+op+" "+y,y==0 ? 0 : op.equals("%") ? x%y : x/y,riscv.regs[10]);
+ }
+ }
+ }
+ private static String integerEdges() {
+ return integerEdges(new long[]{Long.MIN_VALUE,Long.MIN_VALUE+1,-17,-5,-1,0,1,5,17,Long.MAX_VALUE});
+ }
+ private static String integerEdges(long[] values) {
+ StringBuilder source=new StringBuilder("""
+ val rem_noInline={ i64 x,i64 y -> x%y; };
+ val div_noInline={ i64 x,i64 y -> x/y; };
+ val main={ ->
+ """);
+ int failure=1;
+ for( long x : values )
+ for( long y : values ) {
+ source.append("if(rem_noInline(").append(literal(x)).append(',').append(literal(y))
+ .append(")!=").append(literal(y==0 ? 0 : x%y)).append(") return ").append(failure++).append(';');
+ source.append("if(div_noInline(").append(literal(x)).append(',').append(literal(y))
+ .append(")!=").append(literal(y==0 ? 0 : x/y)).append(") return ").append(failure++).append(';');
+ }
+ return source.append("return 0; };").toString();
+ }
+ @Test public void nativeFloatingEdges() throws Exception {
+ double[][] cases={{Double.MAX_VALUE,0.1},{-Double.MAX_VALUE,0.1},
+ {Double.MIN_VALUE,1.0},{1.0,Double.POSITIVE_INFINITY},
+ {-0.0,Double.NEGATIVE_INFINITY},{-5.0,2.5},
+ {Double.POSITIVE_INFINITY,1.0},{Double.NaN,2.0},{2.0,Double.NaN},{1.0,-0.0}};
+ StringBuilder source=new StringBuilder("val rem_noInline={ f64 x,f64 y -> x%y; }; val main={ -> ");
+ for( int i=0; i<cases.length; i++ ) {
+ double x=cases[i][0],y=cases[i][1],r=x%y;
+ source.append("f64 r").append(i).append("=rem_noInline(sys.math.f64FromBits(")
+ .append(literal(Double.doubleToRawLongBits(x))).append("),sys.math.f64FromBits(")
+ .append(literal(Double.doubleToRawLongBits(y))).append(")); if(");
+ if( Double.isNaN(r) ) source.append('r').append(i).append("==r").append(i);
+ else source.append("sys.math.f64Bits(r").append(i).append(")!=").append(literal(Double.doubleToRawLongBits(r)));
+ source.append(") return ").append(i+1).append(";");
+ }
+ TestC.runSYS(source.append("return 0; };").toString(),"modFloatEdges","",-1);
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/SchedulingTest.java b/chapter31/src/test/java/com/seaofnodes/simple/SchedulingTest.java
new file mode 100644
index 00000000..16e12b0f
--- /dev/null
+++ b/chapter31/src/test/java/com/seaofnodes/simple/SchedulingTest.java
@@ -0,0 +1,47 @@
+package com.seaofnodes.simple;
+
+import org.junit.Test;
+
+public class SchedulingTest {
+ @Test public void nativeFoldedLoadsWithLaterOperands() throws Exception {
+ TestC.runSYS("""
+ val compare_noInline={ i64[] a, int flag ->
+ i64 x=a[0];
+ i64 y=flag ? a[1] : a[2];
+ return x==y;
+ };
+ val add_noInline={ i64[] a, int flag ->
+ i64 x=a[0];
+ i64 y=flag ? a[1] : a[2];
+ return x+y;
+ };
+ val main={ ->
+ val a=new i64[3]; a[0]=17; a[1]=17; a[2]=23;
+ if(!compare_noInline(a,1) || compare_noInline(a,0)) return 1;
+ if(add_noInline(a,1)!=34 || add_noInline(a,0)!=40) return 2;
+ return 0;
+ };
+ ""","scheduleLaterOperands","",-1);
+ }
+
+ @Test public void nativeLoadsAcrossWrites() throws Exception {
+ TestC.runSYS("""
+ val change_noInline={ i64[] a -> a[0]=a[1]; return a[0]; };
+ val compare_noInline={ i64[] a ->
+ i64 x=a[0];
+ return x==change_noInline(a);
+ };
+ val add_noInline={ i64[] a ->
+ i64 x=a[0];
+ return x+change_noInline(a);
+ };
+ val main={ ->
+ val a=new i64[2]; a[0]=17; a[1]=23;
+ if(compare_noInline(a)) return 1;
+ a[0]=17; a[1]=29;
+ if(add_noInline(a)!=46) return 2;
+ return 0;
+ };
+ ""","scheduleAcrossWrites","",-1);
+ }
+}
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/StreamIOTest.java b/chapter31/src/test/java/com/seaofnodes/simple/StreamIOTest.java
index 7b459e75..79b95c03 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/StreamIOTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/StreamIOTest.java
@@ -88,7 +88,7 @@ public class StreamIOTest extends TestC {
val bytes=sys.io.read(700);
if(!bytes) return 1;
if(bytes#!=24593) return 2;
- for(u32 i=0; i<bytes#; i++) if(bytes[i]!=i-(i/251)*251) return 3;
+ for(u32 i=0; i<bytes#; i++) if(bytes[i]!=i%251) return 3;
test_io_mode(1,0);
if(sys.io.write(701,bytes)!=bytes# || test_io_count()!=bytes#) return 4;
if(test_io_status()) return 5;
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/StringFormatTest.java b/chapter31/src/test/java/com/seaofnodes/simple/StringFormatTest.java
index 05e801dc..59b62709 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/StringFormatTest.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/StringFormatTest.java
@@ -25,6 +25,11 @@ public class StringFormatTest extends TestC {
"+00017|0x00002a|abc |1.25|A|false\n");
}
+ @Test public void testRemainderInInterpolation() throws Exception {
+ prints("int mod=17; sys.io.p(\"%(mod%5)|%02d(mod%5)|%%|\\%|%(mod %= 5)|%(mod)\");",
+ "2|02|%|%|2|2");
+ }
+
@Test public void testIntegerLimits() throws Exception {
prints("i64 lo=-9223372036854775807-1; sys.io.p(\"%(lo)|%(9223372036854775807)|%u(-1)|%X(-1)\");",
"-9223372036854775808|9223372036854775807|18446744073709551615|FFFFFFFFFFFFFFFF");
diff --git a/chapter31/src/test/java/com/seaofnodes/simple/TestC.java b/chapter31/src/test/java/com/seaofnodes/simple/TestC.java
index 63bb98da..9654382c 100644
--- a/chapter31/src/test/java/com/seaofnodes/simple/TestC.java
+++ b/chapter31/src/test/java/com/seaofnodes/simple/TestC.java
@@ -203,7 +203,7 @@ public abstract class TestC {
params.add(runtimeObject("simple_args"));
}
params.addAll(new String[] {
- "-lm", // Picks up 'sqrt' for newtonFloat tests to compare
+ "-lm", // sys.math functions, floating remainder, and C test drivers
"-g", // debug symbols
"-o", // name the output file
exe, // name the output file