Fix macOS ARM RESIZE test failure and add Windows platform support

Fix compiled RESIZE to return original address on failure (Forth 2012
spec), fixing the macOS ARM test failure. Add #ifdef _WIN32 guards to
POSIX-specific CODE words (KEY?, MS, UTIME, SYSTEM, SETENV, RESIZE-FILE)
and runtime headers. Update codegen to keep conditional #include
directives in function bodies rather than extracting them globally.
Add Windows defaults for CLI (gcc, .exe), test infrastructure (exe
suffix, gcc fallback), and CI (MSYS2/MinGW test job).

Author: ncw

.github/workflows/ci.yml

@@ -32,15 +32,26 @@ jobs:
           name: ccforth-${{ matrix.os }}
           path: ccforth
 
-  build-windows:
+  test-windows:
     runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
     steps:
+      - uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          install: mingw-w64-x86_64-gcc
+
       - uses: actions/checkout@v4
 
       - uses: actions/setup-go@v5
         with:
           go-version: "1.25"
 
+      - name: Run tests
+        run: go test ./...
+
       - name: Build binary
         run: go build -o ccforth.exe ./cmd/ccforth
 

bench_test.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"sort"
 	"strings"
 	"testing"
@@ -59,8 +60,16 @@ func compileForBench(b *testing.B, fthFile string) string {
 		b.Fatalf("write C error: %v", err)
 	}
 
-	exeFile := filepath.Join(tmpDir, "bench")
-	cmd := exec.Command("cc", "-std=c11", "-O3", "-march=native", "-flto", "-o", exeFile, cFile, "-lm")
+	exeSuffix := ""
+	if runtime.GOOS == "windows" {
+		exeSuffix = ".exe"
+	}
+	exeFile := filepath.Join(tmpDir, "bench"+exeSuffix)
+	cc, err := findCC()
+	if err != nil {
+		b.Skip("C compiler not found")
+	}
+	cmd := exec.Command(cc, "-std=c11", "-O3", "-march=native", "-flto", "-o", exeFile, cFile, "-lm")
 	var compileErr bytes.Buffer
 	cmd.Stderr = &compileErr
 	if err := cmd.Run(); err != nil {
@@ -97,7 +106,7 @@ func loadForInterpreter(b *testing.B, fthFile string) *interpreter.Interpreter {
 // BenchmarkCompiled benchmarks compiled (.fth -> C -> native) execution.
 // Each sub-benchmark compiles once during setup, then runs the binary b.N times.
 func BenchmarkCompiled(b *testing.B) {
-	if _, err := exec.LookPath("cc"); err != nil {
+	if _, err := findCC(); err != nil {
 		b.Skip("C compiler not found")
 	}
 
@@ -178,7 +187,7 @@ func BenchmarkGforth(b *testing.B) {
 
 // BenchmarkFib benchmarks the Fibonacci benchmark compiled.
 func BenchmarkFib(b *testing.B) {
-	if _, err := exec.LookPath("cc"); err != nil {
+	if _, err := findCC(); err != nil {
 		b.Skip("C compiler not found")
 	}
 	exeFile := compileForBench(b, "testdata/end-to-end/bench.fth")

cmd/ccforth/main.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 
 	"github.com/chzyer/readline"
@@ -15,9 +16,15 @@ import (
 )
 
 func main() {
-	outputPath := flag.String("o", "a.out", "output executable path")
+	defaultOutput := "a.out"
+	defaultCC := "cc"
+	if runtime.GOOS == "windows" {
+		defaultOutput = "a.exe"
+		defaultCC = "gcc"
+	}
+	outputPath := flag.String("o", defaultOutput, "output executable path")
 	emitCOnly := flag.Bool("c", false, "emit C only, don't invoke compiler")
-	ccCompiler := flag.String("cc", "cc", "C compiler to use")
+	ccCompiler := flag.String("cc", defaultCC, "C compiler to use")
 	cFlags := flag.String("Cflags", "", "extra flags for C compiler")
 	entryWord := flag.String("entry", "MAIN", "entry word")
 	memSize := flag.Int("memsize", 1048576, "FORTH memory size in bytes")

integration_test.go

@@ -69,27 +69,33 @@ func isInterpreterOnly(path string) bool {
 	return strings.HasPrefix(string(data), "\\ INTERPRETER-ONLY")
 }
 
-// knownFailures lists tests that fail on specific GOOS/GOARCH combinations.
-var knownFailures = map[string]map[string]string{
-	"memory_alloc.fth": {"darwin/arm64": "RESIZE behaviour differs on macOS ARM"},
+// findCC returns the path to a C compiler, trying "cc" first then "gcc".
+func findCC() (string, error) {
+	if cc, err := exec.LookPath("cc"); err == nil {
+		return cc, nil
+	}
+	if gcc, err := exec.LookPath("gcc"); err == nil {
+		return gcc, nil
+	}
+	return "", fmt.Errorf("no C compiler found (tried cc, gcc)")
 }
 
 func TestEndToEnd(t *testing.T) {
-	if _, err := exec.LookPath("cc"); err != nil {
+	cc, err := findCC()
+	if err != nil {
 		t.Skip("C compiler not found, skipping end-to-end tests")
 	}
 
-	platform := runtime.GOOS + "/" + runtime.GOARCH
+	exeSuffix := ""
+	if runtime.GOOS == "windows" {
+		exeSuffix = ".exe"
+	}
+
 	for _, tt := range discoverTests(t) {
 		t.Run(filepath.Base(tt.source), func(t *testing.T) {
 			if isInterpreterOnly(tt.source) {
 				t.Skip("interpreter-only test")
 			}
-			if reasons, ok := knownFailures[filepath.Base(tt.source)]; ok {
-				if reason, ok := reasons[platform]; ok {
-					t.Skipf("known failure on %s: %s", platform, reason)
-				}
-			}
 
 			expected, err := os.ReadFile(tt.expectedFile)
 			if err != nil {
@@ -131,8 +137,8 @@ func TestEndToEnd(t *testing.T) {
 			}
 
 			// Compile
-			exeFile := filepath.Join(tmpDir, "output")
-			cmd := exec.Command("cc", "-std=c11", "-O2",
+			exeFile := filepath.Join(tmpDir, "output"+exeSuffix)
+			cmd := exec.Command(cc, "-std=c11", "-O2",
 				"-o", exeFile,
 				cFile,
 				"-lm",
@@ -160,7 +166,6 @@ func TestEndToEnd(t *testing.T) {
 }
 
 func TestEndToEndInterpreter(t *testing.T) {
-	platform := runtime.GOOS + "/" + runtime.GOARCH
 	for _, tt := range discoverTests(t) {
 		t.Run(filepath.Base(tt.source), func(t *testing.T) {
 			// Skip benchmarks in interpreter mode — they are too slow and
@@ -169,11 +174,6 @@ func TestEndToEndInterpreter(t *testing.T) {
 			if strings.Contains(tt.source, "benchmarks/") || base == "bench.fth" || base == "whetstone.fth" {
 				t.Skip("benchmark file, skipping in interpreter mode")
 			}
-			if reasons, ok := knownFailures[base]; ok {
-				if reason, ok := reasons[platform]; ok {
-					t.Skipf("known failure on %s: %s", platform, reason)
-				}
-			}
 			expected, err := os.ReadFile(tt.expectedFile)
 			if err != nil {
 				t.Fatalf("read expected: %v", err)

pkg/codegen/codegen.go

@@ -374,14 +374,20 @@ func (cg *CodeGen) emitValueInit(buf *bytes.Buffer, values []*dictionary.DictEnt
 	}
 }
 
-// collectIncludes extracts #include lines from CODE words, de-duplicated.
+// collectIncludes extracts unconditional #include lines from CODE words, de-duplicated.
+// Includes inside #ifdef/#ifndef blocks are left in the function body for the preprocessor.
 func (cg *CodeGen) collectIncludes(codeWords []*dictionary.DictEntry) []string {
 	seen := map[string]bool{}
 	var result []string
 	for _, w := range codeWords {
+		depth := 0
 		for _, line := range strings.Split(w.CCode, "\n") {
 			trimmed := strings.TrimSpace(line)
-			if strings.HasPrefix(trimmed, "#include") && !seen[trimmed] {
+			if strings.HasPrefix(trimmed, "#ifdef") || strings.HasPrefix(trimmed, "#ifndef") {
+				depth++
+			} else if strings.HasPrefix(trimmed, "#endif") {
+				depth--
+			} else if strings.HasPrefix(trimmed, "#include") && depth == 0 && !seen[trimmed] {
 				seen[trimmed] = true
 				result = append(result, trimmed)
 			}

pkg/compiler/emitter.go

@@ -915,10 +915,17 @@ func (e *Emitter) EmitCodeWord(entry *dictionary.DictEntry) string {
 	e.emitLineDirective(entry.SourceFile, entry.SourceLine)
 	e.EmitLine("static inline void %s(void) {", funcName)
 	e.Indent++
-	// Emit each line of C code, skipping #include lines
+	// Emit each line of C code, skipping unconditional #include lines
+	// (includes inside #ifdef/#ifndef blocks are kept for the preprocessor)
+	ifdefDepth := 0
 	for _, line := range strings.Split(entry.CCode, "\n") {
 		trimmed := strings.TrimSpace(line)
-		if strings.HasPrefix(trimmed, "#include") {
+		if strings.HasPrefix(trimmed, "#ifdef") || strings.HasPrefix(trimmed, "#ifndef") {
+			ifdefDepth++
+		} else if strings.HasPrefix(trimmed, "#endif") {
+			ifdefDepth--
+		}
+		if strings.HasPrefix(trimmed, "#include") && ifdefDepth == 0 {
 			continue
 		}
 		e.EmitLine("%s", line)

pkg/forth/core.fth

@@ -228,7 +228,11 @@ INTERPRETER [IF] [ELSE]
       cell_t _vu = POP(); unsigned char *_vp = CADDR(POP());
       unsigned char _ns = _np[_nu]; _np[_nu] = 0;
       unsigned char _vs = _vp[_vu]; _vp[_vu] = 0;
+      #ifdef _WIN32
+      cell_t _r = _putenv_s((char*)_np, (char*)_vp);
+      #else
       cell_t _r = setenv((char*)_np, (char*)_vp, 1);
+      #endif
       _np[_nu] = _ns; _vp[_vu] = _vs;
       PUSH(_r); }
   ;CODE
@@ -329,7 +333,7 @@ INTERPRETER [IF] [ELSE]
     cell_t _n = POP();
     void* _p = (void*)(uintptr_t)POP();
     void* _new = realloc(_p, (size_t)_n);
-    PUSH(_new ? (cell_t)(uintptr_t)_new : 0);
+    PUSH(_new ? (cell_t)(uintptr_t)_new : (cell_t)(uintptr_t)_p);
     PUSH(_new ? 0 : -1);
   ;CODE
 [THEN]
@@ -358,12 +362,18 @@ INTERPRETER [IF] [ELSE]
 INTERPRETER [IF] [ELSE]
   CODE SYSTEM
     #include <stdlib.h>
+    #ifndef _WIN32
     #include <sys/wait.h>
+    #endif
     cell_t _u = POP(); cell_t _a = POP();
     char _cmd[4096]; if (_u > 4095) _u = 4095;
     memcpy(_cmd, CADDR(_a), (size_t)_u); _cmd[_u] = 0;
     int _rc = system(_cmd);
+    #ifdef _WIN32
+    PUSH(_rc);
+    #else
     PUSH(WIFEXITED(_rc) ? WEXITSTATUS(_rc) : -1);
+    #endif
   ;CODE
 [THEN]
 
@@ -638,7 +648,11 @@ INTERPRETER [IF] [ELSE]
   CODE RESIZE-FILE
     cell_t _fid = POP(); POP(); cell_t _sz = POP();
     if (_fid < 0 || _fid >= MAX_FILES || !file_table[_fid]) { PUSH(-1); return; }
+    #ifdef _WIN32
+    PUSH(_chsize_s(_fileno(file_table[_fid]), _sz) == 0 ? 0 : -1);
+    #else
     PUSH(ftruncate(fileno(file_table[_fid]), (off_t)_sz) == 0 ? 0 : -1);
+    #endif
   ;CODE
   CODE READ-LINE
     cell_t _fid = POP(); cell_t _max = POP(); cell_t _a = POP();
@@ -692,14 +706,24 @@ INTERPRETER [IF] [ELSE]
     printf("\033[2J\033[H"); fflush(stdout);
   ;CODE
   CODE KEY?
+    #ifdef _WIN32
+    #include <conio.h>
+    PUSH(_kbhit() ? -1 : 0);
+    #else
     #include <sys/select.h>
     { fd_set _fds; struct timeval _tv = {0, 0}; FD_ZERO(&_fds); FD_SET(0, &_fds);
       PUSH(select(1, &_fds, NULL, NULL, &_tv) > 0 ? -1 : 0); }
+    #endif
   ;CODE
   CODE MS
-    #include <time.h>
     fflush(stdout);
+    #ifdef _WIN32
+    #include <windows.h>
+    { cell_t _ms = POP(); Sleep((DWORD)_ms); }
+    #else
+    #include <time.h>
     { cell_t _ms = POP(); struct timespec _ts = { _ms / 1000, (_ms % 1000) * 1000000L }; nanosleep(&_ts, NULL); }
+    #endif
   ;CODE
   CODE TIME&DATE
     #include <time.h>
@@ -708,10 +732,18 @@ INTERPRETER [IF] [ELSE]
       PUSH(_tm->tm_mday); PUSH(_tm->tm_mon + 1); PUSH(_tm->tm_year + 1900); }
   ;CODE
   CODE UTIME
+    #ifdef _WIN32
+    #include <windows.h>
+    { FILETIME _ft; GetSystemTimePreciseAsFileTime(&_ft);
+      uint64_t _t = ((uint64_t)_ft.dwHighDateTime << 32) | _ft.dwLowDateTime;
+      _t = _t / 10 - 11644473600000000ULL;
+      PUSH((cell_t)_t); PUSH(0); }
+    #else
     #include <sys/time.h>
     { struct timeval _tv; gettimeofday(&_tv, NULL);
       PUSH((cell_t)((uint64_t)_tv.tv_sec * 1000000ULL + (uint64_t)_tv.tv_usec));
       PUSH(0); }
+    #endif
   ;CODE
   CODE XEMIT
     { cell_t _xc = POP(); unsigned char _buf[4]; int _n;

runtime/runtime.c.src

@@ -1,11 +1,15 @@
+#ifndef _WIN32
 #define _POSIX_C_SOURCE 200809L
+#endif
 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <setjmp.h>
+#ifndef _WIN32
 #include <unistd.h>
+#endif
 #include <math.h>
 
 typedef int64_t cell_t;

testdata/end-to-end/forth2012/memory_alloc.fth

@@ -59,10 +59,7 @@ T{ ADDR1 @ 200 CHARS RESIZE SWAP ADDR1 ! -> 0 }T
 T{ ADDR1 @ 28 CHECKMEM -> TRUE }T
 
 \ Failure of RESIZE and ALLOCATE
-[ INTERPRETER ] [IF]
-\ Compiled RESIZE doesn't preserve original addr on failure
 T{ ADDR1 @ -1 CHARS RESIZE 0= -> ADDR1 @ FALSE }T
-[THEN]
 
 T{ ADDR1 @ FREE -> 0 }T