Fix macOS ARM RESIZE test failure and add Windows platform support

Fix compiled RESIZE to return original address on failure (Forth 2012
spec), with early return for negative sizes to avoid platform-specific
realloc edge cases. Add #ifdef _WIN32 guards to POSIX-specific CODE
words (KEY?, MS, UTIME, SYSTEM, SETENV, RESIZE-FILE) and runtime
headers. Update codegen to extract conditional #include directives to
the top level with proper #ifdef guards. Add Windows defaults for CLI
(gcc, .exe), test infrastructure (exe suffix, gcc fallback), and CI
(MSYS2/MinGW test job with PATH inheritance).

Author: ncw

.github/workflows/ci.yml

@@ -32,15 +32,27 @@ 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
+          path-type: inherit
+          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

@@ -53,6 +53,8 @@ func discoverTests(t *testing.T) []struct{ source, expectedFile string } {
 }
 
 func normalize(s string) string {
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+	s = strings.ReplaceAll(s, "\r", "\n")
 	lines := strings.Split(s, "\n")
 	for i, line := range lines {
 		lines[i] = strings.TrimRight(line, " ")
@@ -69,27 +71,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 +139,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 +168,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 +176,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,19 +374,70 @@ func (cg *CodeGen) emitValueInit(buf *bytes.Buffer, values []*dictionary.DictEnt
 	}
 }
 
-// collectIncludes extracts #include lines from CODE words, de-duplicated.
+// collectIncludes extracts #include lines from CODE words, preserving #ifdef guards.
+// Includes are grouped by their preprocessor guard context and de-duplicated.
 func (cg *CodeGen) collectIncludes(codeWords []*dictionary.DictEntry) []string {
-	seen := map[string]bool{}
-	var result []string
+	type guardedInclude struct {
+		guard   string // "" for unconditional, or e.g. "#ifdef _WIN32", "#ifndef _WIN32"
+		include string
+	}
+	seen := map[string]bool{} // "guard|include" dedup key
+	var includes []guardedInclude
+
 	for _, w := range codeWords {
+		var guardStack []string
 		for _, line := range strings.Split(w.CCode, "\n") {
 			trimmed := strings.TrimSpace(line)
-			if strings.HasPrefix(trimmed, "#include") && !seen[trimmed] {
-				seen[trimmed] = true
-				result = append(result, trimmed)
+			if strings.HasPrefix(trimmed, "#ifdef") || strings.HasPrefix(trimmed, "#ifndef") {
+				guardStack = append(guardStack, trimmed)
+			} else if strings.HasPrefix(trimmed, "#else") {
+				if len(guardStack) > 0 {
+					last := guardStack[len(guardStack)-1]
+					if strings.HasPrefix(last, "#ifdef") {
+						guardStack[len(guardStack)-1] = "#ifndef" + last[len("#ifdef"):]
+					} else if strings.HasPrefix(last, "#ifndef") {
+						guardStack[len(guardStack)-1] = "#ifdef" + last[len("#ifndef"):]
+					}
+				}
+			} else if strings.HasPrefix(trimmed, "#endif") {
+				if len(guardStack) > 0 {
+					guardStack = guardStack[:len(guardStack)-1]
+				}
+			} else if strings.HasPrefix(trimmed, "#include") {
+				guard := ""
+				if len(guardStack) > 0 {
+					guard = guardStack[len(guardStack)-1]
+				}
+				key := guard + "|" + trimmed
+				if !seen[key] {
+					seen[key] = true
+					includes = append(includes, guardedInclude{guard: guard, include: trimmed})
+				}
 			}
 		}
 	}
+
+	// Group by guard for cleaner output
+	groups := map[string][]string{} // guard -> includes
+	var guardOrder []string
+	for _, gi := range includes {
+		if _, ok := groups[gi.guard]; !ok {
+			guardOrder = append(guardOrder, gi.guard)
+		}
+		groups[gi.guard] = append(groups[gi.guard], gi.include)
+	}
+
+	var result []string
+	for _, guard := range guardOrder {
+		incs := groups[guard]
+		if guard == "" {
+			result = append(result, incs...)
+		} else {
+			result = append(result, guard)
+			result = append(result, incs...)
+			result = append(result, "#endif")
+		}
+	}
 	return result
 }
 

pkg/compiler/emitter.go

@@ -67,7 +67,8 @@ func (e *Emitter) emitLineDirective(file string, line int) {
 	}
 	e.lastFile = file
 	e.lastLine = line
-	fmt.Fprintf(e.Buf, "#line %d \"%s\"\n", line, file)
+	// Use forward slashes in #line paths to avoid C escape sequence issues on Windows
+	fmt.Fprintf(e.Buf, "#line %d \"%s\"\n", line, strings.ReplaceAll(file, "\\", "/"))
 }
 
 // resetLineState resets the #line tracking state so the next emission gets a fresh directive.
@@ -915,7 +916,7 @@ 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 #include lines (they are extracted to the top)
 	for _, line := range strings.Split(entry.CCode, "\n") {
 		trimmed := strings.TrimSpace(line)
 		if strings.HasPrefix(trimmed, "#include") {

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
@@ -316,9 +320,10 @@ VARIABLE HLD
 INTERPRETER [IF] [ELSE]
   CODE ALLOCATE
     cell_t _n = POP();
-    void* _p = malloc((size_t)_n);
+    if (_n < 0) { PUSH(0); PUSH(-1); }
+    else { void* _p = malloc((size_t)_n);
     PUSH(_p ? (cell_t)(uintptr_t)_p : 0);
-    PUSH(_p ? 0 : -1);
+    PUSH(_p ? 0 : -1); }
   ;CODE
   CODE FREE
     void* _p = (void*)(uintptr_t)POP();
@@ -328,9 +333,10 @@ INTERPRETER [IF] [ELSE]
   CODE RESIZE
     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 ? 0 : -1);
+    if (_n < 0) { PUSH((cell_t)(uintptr_t)_p); PUSH(-1); }
+    else { void* _new = realloc(_p, (size_t)_n);
+    PUSH(_new ? (cell_t)(uintptr_t)_new : (cell_t)(uintptr_t)_p);
+    PUSH(_new ? 0 : -1); }
   ;CODE
 [THEN]
 
@@ -358,12 +364,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 +650,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 +708,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 +734,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;