feat: add C source file support and string replacement functionality

Signed-off-by: Ariel Simulevski <ariel@simulevski.at>

Author: Azer0s

examples/csource_test/helper.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int add(int a, int b) { return a + b; }
+
+#ifdef DEBUG
+void greet() { printf("debug mode\n"); }
+#else
+void greet() { printf("release mode\n"); }
+#endif

examples/csource_test/main.tin

@@ -0,0 +1,9 @@
+//!+helper.c
+
+fn add(a i64, b i64) i64 = extern("add")
+fn greet() = extern("greet")
+
+fn main() =
+  let x i64 = add(3, 4)
+  echo x
+  greet()

examples/csource_test/main_debug.tin

@@ -0,0 +1,6 @@
+//!+helper.c -- -DDEBUG
+
+fn greet() = extern("greet")
+
+fn main() =
+  greet()

main.go

@@ -30,34 +30,61 @@ Linker flags (passed after the source file):
   -lNAME       link with libNAME (e.g. -lm for libmath)
   -LDIR        add DIR to the library search path
   file.o/.a    link with extra object/archive file
+
+In-source directives (at the top of the .tin file):
+  //!-lNAME            link with libNAME
+  //!+file.c           compile C source file alongside the tin module
+  //!+file.c -- FLAGS  compile C source with extra clang flags
 `
 
-// parseFileLinkerFlags scans the leading lines of src for //! directives and
-// returns the flags they specify.  Each directive line has the form:
+// cSource represents a C source file to compile alongside the tin module,
+// optionally with extra clang flags (from //!+file.c -- -DFOO directives).
+type cSource struct {
+	path  string
+	flags []string
+}
+
+// parseFileDirectives scans the leading lines of src for //! directives and
+// returns linker flags and C source files to compile in.
 //
-//	//!-lm
-//	//!-lraylib
-//	//!-L/usr/local/lib
+//	//!-lm            → linker flag -lm
+//	//!-lraylib       → linker flag -lraylib
+//	//!-L/usr/local/lib → linker flag -L/usr/local/lib
+//	//!+helper.c      → compile helper.c alongside the module
+//	//!+src/foo.c -- -DDEBUG → compile src/foo.c with extra flag -DDEBUG
 //
-// Scanning stops at the first line that is not a comment or blank
-func parseFileLinkerFlags(src string) []string {
-	var flags []string
+// srcDir is the directory of the .tin file; relative C source paths are
+// resolved against it. Scanning stops at the first non-comment, non-blank line.
+func parseFileDirectives(src, srcDir string) (linkerFlags []string, cSources []cSource) {
 	for _, line := range strings.SplitAfter(src, "\n") {
 		trimmed := strings.TrimSpace(line)
 		if trimmed == "" || strings.HasPrefix(trimmed, "//") && !strings.HasPrefix(trimmed, "//!") {
-			// blank or ordinary comment - keep scanning
 			continue
 		}
 		if strings.HasPrefix(trimmed, "//!") {
-			flag := strings.TrimSpace(trimmed[3:])
-			if flag != "" {
-				flags = append(flags, flag)
+			rest := strings.TrimSpace(trimmed[3:])
+			if rest == "" {
+				continue
+			}
+			if strings.HasPrefix(rest, "+") {
+				spec := strings.TrimSpace(rest[1:])
+				parts := strings.SplitN(spec, " -- ", 2)
+				cpath := filepath.Join(srcDir, strings.TrimSpace(parts[0]))
+				var extraFlags []string
+				if len(parts) == 2 {
+					for _, f := range strings.Fields(parts[1]) {
+						extraFlags = append(extraFlags, f)
+					}
+				}
+				cSources = append(cSources, cSource{path: cpath, flags: extraFlags})
+			} else {
+				linkerFlags = append(linkerFlags, rest)
 			}
 			continue
 		}
-		break // first non-comment, non-blank line - stop
+		break
 	}
-	return flags
+	return
 }
 
 func main() {
@@ -102,8 +129,8 @@ func main() {
 		die("error reading file: %v", err)
 	}
 
-	// Collect linker flags declared in the source file via //! directives
-	fileLinkerFlags := parseFileLinkerFlags(string(src))
+	// Collect directives declared in the source file via //! lines
+	fileLinkerFlags, fileCSources := parseFileDirectives(string(src), filepath.Dir(file))
 
 	// Lex
 	l := lexer.New(string(src))
@@ -178,7 +205,7 @@ func main() {
 			}
 		}
 		extraObjs = append(srcLinkFlags, extraObjs...)
-		if err := compileIR(irText, out, libMode, extraObjs); err != nil {
+		if err := compileIR(irText, out, libMode, extraObjs, fileCSources); err != nil {
 			die("compile error: %v", err)
 		}
 
@@ -199,7 +226,7 @@ func main() {
 			}
 		}
 		extraObjs = append(srcLinkFlags, extraObjs...)
-		if err := compileIR(irText, out, false, extraObjs); err != nil {
+		if err := compileIR(irText, out, false, extraObjs, fileCSources); err != nil {
 			die("compile error: %v", err)
 		}
 
@@ -217,7 +244,7 @@ func main() {
 			}
 		}
 		extraObjs = append(srcLinkFlags, extraObjs...)
-		if err := compileIR(irText, tmp, false, extraObjs); err != nil {
+		if err := compileIR(irText, tmp, false, extraObjs, fileCSources); err != nil {
 			die("compile error: %v", err)
 		}
 		defer func(name string) {
@@ -240,10 +267,11 @@ func main() {
 	}
 }
 
-// compileIR writes the LLVM IR to a temp .ll file and invokes clang
-// If libMode is true, compile to an object file with -c (no linking)
-// extraObjs are additional .o/.a files to link with
-func compileIR(ir, outBin string, libMode bool, extraObjs []string) error {
+// compileIR writes the LLVM IR to a temp .ll file and invokes clang.
+// If libMode is true, compile to an object file with -c (no linking).
+// extraObjs are additional .o/.a files and -l/-L flags to pass to the linker.
+// cSources are C source files to compile in alongside the IR.
+func compileIR(ir, outBin string, libMode bool, extraObjs []string, cSources []cSource) error {
 	// Write IR to temp file
 	//goland:noinspection GoResourceLeak
 	llFile, err := os.CreateTemp("", "tin-*.ll")
@@ -263,18 +291,71 @@ func compileIR(ir, outBin string, libMode bool, extraObjs []string) error {
 	rtC := filepath.Join(filepath.Dir(ex), "runtime", "runtime.c")
 
 	if libMode {
-		// Library mode: compile to object file only (-c), no runtime, no linking
-		args := []string{"-O2", "-c", llFile.Name(), "-o", outBin}
-		clang := exec.Command("clang", args...)
-		clang.Stdout = os.Stdout
-		clang.Stderr = os.Stderr
-		return clang.Run()
+		// Library mode: compile to object file(s) with -c, then merge with ld -r.
+		// clang -c cannot write multiple inputs to a single -o, so each source is
+		// compiled separately and the results are partially linked together.
+		irObj, err := os.CreateTemp("", "tin-ir-*.o")
+		if err != nil {
+			return fmt.Errorf("cannot create temp object file: %w", err)
+		}
+		irObjName := irObj.Name()
+		_ = irObj.Close()
+		defer func() { _ = os.Remove(irObjName) }()
+
+		clangIR := exec.Command("clang", "-O2", "-c", llFile.Name(), "-o", irObjName)
+		clangIR.Stdout = os.Stdout
+		clangIR.Stderr = os.Stderr
+		if err := clangIR.Run(); err != nil {
+			return err
+		}
+
+		objs := []string{irObjName}
+		var tmpObjs []string
+		for _, cs := range cSources {
+			cObj, err := os.CreateTemp("", "tin-c-*.o")
+			if err != nil {
+				return fmt.Errorf("cannot create temp object file: %w", err)
+			}
+			cObjName := cObj.Name()
+			_ = cObj.Close()
+			tmpObjs = append(tmpObjs, cObjName)
+			cArgs := []string{"-O2", "-c"}
+			cArgs = append(cArgs, cs.flags...)
+			cArgs = append(cArgs, cs.path, "-o", cObjName)
+			clangC := exec.Command("clang", cArgs...)
+			clangC.Stdout = os.Stdout
+			clangC.Stderr = os.Stderr
+			if err := clangC.Run(); err != nil {
+				for _, f := range tmpObjs {
+					_ = os.Remove(f)
+				}
+				return err
+			}
+			objs = append(objs, cObjName)
+		}
+		defer func() {
+			for _, f := range tmpObjs {
+				_ = os.Remove(f)
+			}
+		}()
+
+		// Merge all object files into the final output with ld -r (partial link)
+		ldArgs := append([]string{"-r"}, objs...)
+		ldArgs = append(ldArgs, "-o", outBin)
+		ld := exec.Command("ld", ldArgs...)
+		ld.Stdout = os.Stdout
+		ld.Stderr = os.Stderr
+		return ld.Run()
 	}
 
 	args := []string{"-O2", llFile.Name()}
 	if _, err := os.Stat(rtC); err == nil {
 		args = append(args, rtC)
 	}
+	for _, cs := range cSources {
+		args = append(args, cs.flags...)
+		args = append(args, cs.path)
+	}
 	args = append(args, extraObjs...)
 	args = append(args, "-o", outBin)
 
@@ -333,7 +414,8 @@ func runDirTests(dir string, extraFlags []string) {
 			continue // no test blocks in this file
 		}
 
-		srcLinks := append([]string{}, parseFileLinkerFlags(string(src))...)
+		fileLinks, fCSources := parseFileDirectives(string(src), filepath.Dir(fpath))
+		srcLinks := append([]string{}, fileLinks...)
 		for _, lib := range cg.LinkLibs() {
 			srcLinks = append(srcLinks, "-l"+lib)
 		}
@@ -354,7 +436,7 @@ func runDirTests(dir string, extraFlags []string) {
 		}(tmp.Name())
 
 		irText := mod.String()
-		if compErr := compileIR(irText, tmp.Name(), false, linkFlags); compErr != nil {
+		if compErr := compileIR(irText, tmp.Name(), false, linkFlags, fCSources); compErr != nil {
 			_, _ = fmt.Fprintf(os.Stderr, "  compile error: %v\n", compErr)
 			results = append(results, result{e.Name(), false})
 			continue

runtime/runtime.c

@@ -657,50 +657,6 @@ int32_t _tin_learn_atom(const char *str) {
     return code;
 }
 
-
-// -- String replace helper
-//
-// tin_str_replace(s, old, newstr): returns a new heap-allocated char* with all
-// occurrences of `old` replaced by `newstr`.  Called from stdlib/strings/strings.tin
-// via extern("tin_str_replace").  Note: takes char* (fat-ptr data field, not TinString).
-char *tin_str_replace(const char *s, const char *old, const char *newstr) {
-    if (!s || !old || !newstr) return (char *)s;
-    size_t oldlen = strlen(old);
-    size_t newlen = strlen(newstr);
-    if (oldlen == 0) {
-        char *dup = strdup(s);
-        return dup ? dup : (char *)s;
-    }
-    // Count occurrences
-    size_t count = 0;
-    const char *p = s;
-    while ((p = strstr(p, old)) != NULL) {
-        count++;
-        p += oldlen;
-    }
-    if (count == 0) return strdup(s);
-    // Allocate result
-    size_t slen = strlen(s);
-    size_t rlen = slen + count * (newlen - oldlen) + 1;
-    // But if newlen < oldlen, rlen might underflow - cap at slen+1 min
-    if (newlen < oldlen && count * (oldlen - newlen) > slen) rlen = slen + 1;
-    char *result = (char *)malloc(rlen);
-    if (!result) return strdup(s);
-    char *out = result;
-    p = s;
-    while (*p) {
-        if (strncmp(p, old, oldlen) == 0) {
-            memcpy(out, newstr, newlen);
-            out += newlen;
-            p += oldlen;
-        } else {
-            *out++ = *p++;
-        }
-    }
-    *out = '\0';
-    return result;
-}
-
 // -- any equality
 // Runtime comparison for `any` values - dispatches on the type tag:
 //   0=i64, 1=f64, 2=string/atom, 3=bool, else pointer equality

stdlib/math/math.tin

@@ -1,9 +1,8 @@
+//!-lm
+
 // stdlib/math - Mathematical functions
 //
 // Wraps standard C math.h functions
-// Requires linking with libm: pass -lm when building
-//   tin build myfile.tin -lm
-//   tin run   myfile.tin -lm
 
 // Basic arithmetic