add new build system

dsl/build.go

@@ -0,0 +1,187 @@
+package dsl
+
+// BuildProfile is a named compilation profile. The translator maps it into
+// compiler-specific flag sets at execution time (e.g. ProfileRelease → "-O2"
+// on gnu-like compilers, "/O2" on msvc).
+type BuildProfile int
+
+const (
+	ProfileUnset BuildProfile = iota
+	ProfileRelease
+	ProfileDebug
+	ProfileSanitized
+)
+
+func (p BuildProfile) String() string {
+	switch p {
+	case ProfileRelease:
+		return "release"
+	case ProfileDebug:
+		return "debug"
+	case ProfileSanitized:
+		return "sanitized"
+	default:
+		return "unset"
+	}
+}
+
+// WarningLevel describes how strict the compiler should be about warnings.
+type WarningLevel int
+
+const (
+	WarningsUnset WarningLevel = iota
+	WarningsDefault
+	WarningsStrict
+	WarningsPedantic
+)
+
+func (w WarningLevel) String() string {
+	switch w {
+	case WarningsDefault:
+		return "default"
+	case WarningsStrict:
+		return "strict"
+	case WarningsPedantic:
+		return "pedantic"
+	default:
+		return "unset"
+	}
+}
+
+// BuildConfig describes one structured build variant. It is the new-style
+// replacement for the free-form `build "shell-string"` field.
+//
+// A top-level `build_defaults { ... }` in the suite file produces a
+// BuildConfig stored on File.BuildDefaults. Each `build "name" { ... }`
+// block produces an entry in File.Builds; the effective configuration used
+// by the runner is BuildDefaults merged with the named block, then merged
+// with the OS-specific override (Linux / Windows / Darwin) when present.
+//
+// Zero-valued fields inherit from the parent during merge. Slice and map
+// fields accumulate rather than replace.
+type BuildConfig struct {
+	// Name of the variant. Empty on BuildDefaults and on OS-override sub-blocks.
+	Name string
+
+	Language string   // e.g. "c", "c++"
+	Standard string   // e.g. "c11", "c++17"
+	Sources  []string // globs, relative to work dir
+	Includes []string // include search paths
+	Output   string   // binary name (OS-specific extension added automatically)
+
+	Profile  BuildProfile
+	Warnings WarningLevel
+	Sanitize []string
+	Wrapper  string // e.g. "address", "undefined", "thread"
+
+	Defines map[string]string
+	Link    []string // libraries to link against (e.g. "pthread", "m")
+	Extra   []string // raw passthrough flags
+
+	// Filters — empty means "applies to any". A build is skipped at runtime
+	// if the current OS or compiler is not in the list.
+	Platforms []string // "linux", "windows", "darwin"
+	Compilers []string // "gcc", "clang", "msvc"
+
+	// OS-specific overrides. Only one level of nesting is allowed: these
+	// sub-configs must not themselves contain Linux/Windows/Darwin blocks.
+	Linux   *BuildConfig
+	Windows *BuildConfig
+	Darwin  *BuildConfig
+}
+
+// MergeFrom layers src on top of dst in place. Non-zero scalar fields in src
+// overwrite dst; slices and maps accumulate. The Name and OS override fields
+// on src are intentionally ignored — merging never copies the hierarchy,
+// only the leaves.
+func (dst *BuildConfig) MergeFrom(src *BuildConfig) {
+	if src == nil {
+		return
+	}
+	if src.Language != "" {
+		dst.Language = src.Language
+	}
+	if src.Standard != "" {
+		dst.Standard = src.Standard
+	}
+	if src.Output != "" {
+		dst.Output = src.Output
+	}
+	if src.Profile != ProfileUnset {
+		dst.Profile = src.Profile
+	}
+	if src.Warnings != WarningsUnset {
+		dst.Warnings = src.Warnings
+	}
+	if src.Wrapper != "" {
+		dst.Wrapper = src.Wrapper
+	}
+
+	dst.Sources = append(dst.Sources, src.Sources...)
+	dst.Includes = append(dst.Includes, src.Includes...)
+	dst.Sanitize = append(dst.Sanitize, src.Sanitize...)
+	dst.Link = append(dst.Link, src.Link...)
+	dst.Extra = append(dst.Extra, src.Extra...)
+	dst.Platforms = append(dst.Platforms, src.Platforms...)
+	dst.Compilers = append(dst.Compilers, src.Compilers...)
+
+	if len(src.Defines) > 0 {
+		if dst.Defines == nil {
+			dst.Defines = map[string]string{}
+		}
+		for k, v := range src.Defines {
+			dst.Defines[k] = v
+		}
+	}
+}
+
+// Resolve returns the effective BuildConfig for the given OS by merging
+// BuildDefaults → this block → the matching OS override. The result is a
+// fresh value; the receiver is not mutated.
+func (b *BuildConfig) Resolve(defaults *BuildConfig, os string) BuildConfig {
+	var out BuildConfig
+	out.MergeFrom(defaults)
+	out.MergeFrom(b)
+	out.Name = b.Name
+
+	var osOverride *BuildConfig
+	switch os {
+	case "linux":
+		osOverride = b.Linux
+	case "windows":
+		osOverride = b.Windows
+	case "darwin":
+		osOverride = b.Darwin
+	}
+	out.MergeFrom(osOverride)
+
+	return out
+}
+
+// AppliesTo reports whether this build should run on (os, compiler).
+// An empty Platforms/Compilers list means no filter on that axis.
+func (b *BuildConfig) AppliesTo(os, compiler string) bool {
+	if len(b.Platforms) > 0 && !contains(b.Platforms, os) {
+		return false
+	}
+	if len(b.Compilers) > 0 && !contains(b.Compilers, compiler) {
+		return false
+	}
+	return true
+}
+
+func contains(xs []string, x string) bool {
+	for _, v := range xs {
+		if v == x {
+			return true
+		}
+	}
+	return false
+}
+
+type ToolchainSpec struct {
+	Name      string
+	Platforms []string
+	Binary    string
+	Class     string
+}