zero-build 0.1.0__py3-none-any.whl

zero/__init__.py

@@ -0,0 +1,20 @@
+# Main API classes
+from pathlib import Path
+
+from src.zero.interface.build import Build
+from src.zero.interface.source import Source
+from src.zero.interface.executable import Executable
+from src.zero.interface.static_lib import StaticLibrary
+from src.zero.interface.shared_lib import SharedLibrary
+from src.zero.interface.precomp_lib import PreCompiledLibrary
+
+__all__ = [
+	"Path",
+
+	"Build",
+	"Source",
+	"Executable",
+	"StaticLibrary",
+	"SharedLibrary",
+	"PreCompiledLibrary"
+]

zero/analyzers/cycle_detector.py

@@ -0,0 +1,146 @@
+from src.zero.graph.nodes import Node
+from src.zero.graph.visitor import NodeVisitor
+from src.zero.graph.nodes import *
+
+from src.zero.reporter import getReporter
+
+
+class CycleDetector(NodeVisitor):
+
+
+	def __init__(self) -> None:
+		self.visited_nodes: set[Node] = set()
+		self.tracked_nodes: list[Node] = []
+		self.is_cycle_detected: bool = False
+
+		self.reporter = getReporter()
+
+
+	def getCycle(self, node: Node) -> list[Node]:
+
+		self.is_cycle_detected = True
+		
+		cycle = []
+
+		for i in range(len(self.tracked_nodes)):
+			if self.tracked_nodes[i] == node:
+				cycle = self.tracked_nodes[i:]
+				cycle.append(node)
+				break
+
+		return cycle
+	
+
+	def visit(self, node: Node):
+		
+		if self.is_cycle_detected:
+			return 
+		
+		return super().visit(node)
+	
+
+	def visitRootNode(self, node: RootNode):
+
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+		self.tracked_nodes.append(node)
+
+		for t in node.targets:
+			self.visit(t)
+
+		self.tracked_nodes.pop()
+
+		
+	def visitExecutableNode(self, node: ExecutableNode):
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+		if node in self.tracked_nodes:
+			self.getCycle(node)
+			return
+
+		self.tracked_nodes.append(node)
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+
+		for src in node.sources:
+			self.visit(src)
+
+		self.tracked_nodes.pop()
+
+
+	def visitStaticLibraryNode(self, node: StaticLibraryNode):
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+		if node in self.tracked_nodes:
+			self.getCycle(node)
+			return
+
+		self.tracked_nodes.append(node)
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+
+		for src in node.sources:
+			self.visit(src)
+
+		self.tracked_nodes.pop()
+
+
+	def visitSharedLibraryNode(self, node: SharedLibraryNode):
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+		if node in self.tracked_nodes:
+			self.getCycle(node)
+			return
+
+		self.tracked_nodes.append(node)
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+
+		for src in node.sources:
+			self.visit(src)
+
+		self.tracked_nodes.pop()
+	
+
+	def visitPreCompiledLibraryNode(self, node: PreCompiledLibraryNode):
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+
+	def visitSourceNode(self, node: SourceNode):
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+		if node in self.tracked_nodes:
+			self.getCycle(node)
+			return
+
+		self.tracked_nodes.append(node)
+
+		for header in node.deps:
+			self.visit(header)
+
+		self.tracked_nodes.pop()
+
+
+	def visitHeaderNode(self, node: HeaderNode):
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+
+		if node in self.tracked_nodes:
+			self.getCycle(node)
+			return
+
+		self.tracked_nodes.append(node)
+
+		for header in node.deps:
+			self.visit(header)
+
+		self.tracked_nodes.pop()

zero/analyzers/stale_detector.py

@@ -0,0 +1,167 @@
+from src.zero.graph.nodes import Node
+from src.zero.graph.visitor import NodeVisitor
+from src.zero.graph.nodes import *
+
+from src.zero.reporter import getReporter
+
+
+def markStale(node: Node):
+	setattr(node, "_stale", True)
+
+
+def isStale(node: Node) -> bool:
+	return hasattr(node, "_stale")
+
+
+class StaleDetector(NodeVisitor):
+
+
+	def __init__(self) -> None:
+		self.visited_nodes: set[Node] = set()
+		self.current_source_outpath: Path | None = None	
+		self.stale_count = 0
+
+
+	def markStale(self, node: Node):
+		if not hasattr(node, "_stale"):
+			setattr(node, "_stale", True)
+			self.stale_count += 1
+
+
+	def getStaleCount(self) -> int:
+		return self.stale_count
+		
+
+	def visitRootNode(self, node: RootNode):
+
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+		
+	
+		for t in node.targets:
+			self.visit(t)
+
+
+		
+	def visitExecutableNode(self, node: ExecutableNode):
+
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+		
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+
+			if isStale(lib):
+				self.markStale(node)
+
+		for src in node.sources:
+			self.visit(src)
+
+			if isStale(src):
+				self.markStale(node)
+
+
+	def visitStaticLibraryNode(self, node: StaticLibraryNode):
+
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+
+			if isStale(lib):
+				self.markStale(node)
+
+		for src in node.sources:
+			self.visit(src)
+
+			if isStale(src):
+				self.markStale(node)
+
+
+	def visitSharedLibraryNode(self, node: SharedLibraryNode):
+		
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+
+			if isStale(lib):
+				self.markStale(node)
+
+		for src in node.sources:
+			self.visit(src)
+
+			if isStale(src):
+				self.markStale(node)
+	
+
+	def visitPreCompiledLibraryNode(self, node: PreCompiledLibraryNode):
+		
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+
+
+
+	def visitSourceNode(self, node: SourceNode):
+		
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+
+
+		if not node.outpath.exists():
+			self.markStale(node)
+			return
+		
+		if node.outpath.stat().st_mtime < node.filepath.stat().st_mtime:
+			self.markStale(node)
+			return
+		
+		self.current_source_outpath = node.outpath
+
+		for header in node.deps:
+			self.visit(header)
+
+			if isStale(header):
+				self.markStale(node)
+				return
+
+		self.current_source_outpath = None
+
+
+	def visitHeaderNode(self, node: HeaderNode):
+		
+		if node not in self.visited_nodes:
+			self.visited_nodes.add(node)
+		else:
+			return
+
+		if self.current_source_outpath is None:
+			raise RuntimeError("Source path should not have been None. Unexpected.")
+		
+		if self.current_source_outpath.stat().st_mtime < node.filepath.stat().st_mtime:
+			markStale(node)
+			return
+		
+		for header in node.deps:
+			self.visit(header)
+
+			if isStale(header):
+				markStale(node)
+				return
+

zero/builder/builder.py

@@ -0,0 +1,175 @@
+from src.zero.graph.nodes import *
+from src.zero.graph.nodes import SharedLibraryNode
+from src.zero.graph.visitor import NodeVisitor
+
+from src.zero.compilers import BaseCompiler
+
+from src.zero.orchestrator.config import BuildConfig
+from src.zero.reporter import getReporter
+from src.zero.analyzers.stale_detector import isStale
+
+
+class Builder(NodeVisitor):
+
+	def __init__(self, config: BuildConfig) -> None:
+
+		super().__init__()
+
+		self.fresh_build = config.fresh_build
+
+		self.compiling_shared_lib = False
+
+		self.include_dirs: list[Path] = []
+		self.visited_nodes: set[object] = set()
+		self.current_target_arguments: list[str] = []
+
+		self.reporter = getReporter()
+
+		self.current_compiler: BaseCompiler
+
+
+	def detectStaleness(self, node: Node) -> bool:
+		if self.fresh_build:
+			return True
+		else:
+			return isStale(node)
+
+
+	def visitRootNode(self, node: RootNode):
+		self.reporter.startPhase("Compilation", "Compiling")
+
+		for target in node.targets:
+			self.current_compiler = node.target_compilers[target]
+			self.visit(target)
+
+		self.reporter.endPhase("Build complete")
+
+
+	def visitStaticLibraryNode(self, node: StaticLibraryNode):
+		if node in self.visited_nodes:
+			return
+		
+		if not self.detectStaleness(node):
+			return
+
+		include_dirs = []
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+			include_dirs.extend(lib.public_headers)
+
+		include_dirs.extend(node.public_headers)
+		include_dirs.extend(node.private_headers)
+
+		self.include_dirs = include_dirs
+		
+		self.current_target_arguments = node.arguments
+
+		for deps in node.sources:
+			self.visit(deps)
+
+		self.current_compiler.buildStaticLib([n.outpath for n in node.sources], node.libpath)
+		
+		self.reporter.taskDone("Link ", f"{node.libpath.name}")
+
+		self.visited_nodes.add(node)
+
+
+	def visitSharedLibraryNode(self, node: SharedLibraryNode):
+		if node in self.visited_nodes:
+			return
+		
+		if not self.detectStaleness(node):
+			return
+
+		self.compiling_shared_lib = True
+
+		include_dirs = []
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+			include_dirs.extend(lib.public_headers)
+
+		include_dirs.extend(node.public_headers)
+		include_dirs.extend(node.private_headers)
+
+		self.include_dirs = include_dirs
+
+		self.current_target_arguments = node.arguments
+
+		for deps in node.sources:
+			self.visit(deps)
+
+		self.current_compiler.buildSharedLib([n.outpath for n in node.sources], [l.libpath for l in node.linked_libraries], node.libpath)
+		
+		self.compiling_shared_lib = False
+
+		self.reporter.taskDone("Link ", f"{node.libpath.name}")
+
+		self.visited_nodes.add(node)
+	
+
+	def visitPreCompiledLibraryNode(self, node: PreCompiledLibraryNode):
+
+		if not node.libpath.exists():
+			raise RuntimeError(f"Could not find pre-compiled library: {node.libpath}")
+		
+		self.reporter.taskDone("Found", f"{node.libpath}")
+
+
+	def visitExecutableNode(self, node: ExecutableNode):
+		if node in self.visited_nodes:
+			return
+		
+		if not self.detectStaleness(node):
+			return
+		
+		include_dirs = []
+
+		for lib in node.linked_libraries:
+			self.visit(lib)
+			include_dirs.extend(lib.public_headers)
+
+		include_dirs.extend(node.private_headers)
+
+		self.include_dirs = include_dirs
+
+		self.current_target_arguments = node.arguments
+
+		for deps in node.sources:
+			self.visit(deps)
+
+		self.current_compiler.buildExecutable([n.outpath for n in node.sources], [n.libpath for n in node.linked_libraries], node.targetpath)
+
+		self.reporter.taskDone("Link ", f"{node.targetpath.name}")
+
+		self.visited_nodes.add(node)
+
+		
+	def visitSourceNode(self, node: SourceNode):
+
+		if node in self.visited_nodes:
+			return
+		
+		if not self.detectStaleness(node):
+			return
+
+		for deps in node.deps:
+			self.visit(deps)
+
+		self.current_compiler.buildFile(
+			node.filepath, 
+			node.outpath, 
+			for_shared=self.compiling_shared_lib, 
+			include_dirs=self.include_dirs, 
+			arguments=self.current_target_arguments
+		)
+		
+		self.reporter.taskDone("Built", f"{node.filepath}")
+
+		self.visited_nodes.add(node)
+		
+
+	def visitHeaderNode(self, node: HeaderNode):
+		for deps in node.deps:
+			self.visit(deps)

zero/cli/__main__.py

@@ -0,0 +1,5 @@
+
+from .main import main
+
+if __name__ == "__main__":
+	main()

zero/cli/args.py

@@ -0,0 +1,60 @@
+import argparse
+import sys
+
+
+def add_make_command(subparsers: argparse._SubParsersAction) -> None:
+	make_parser = subparsers.add_parser(
+		"make",
+		help="Build targets",
+	)
+	make_parser.add_argument(
+		"--fresh",
+		action="store_true",
+		help="Force a clean rebuild",
+	)
+	make_parser.add_argument(
+		"target",
+		nargs="*",
+		default=None,
+		help="Target to build",
+	)
+
+
+def add_run_command(subparsers: argparse._SubParsersAction) -> None:
+	run_parser = subparsers.add_parser(
+		"run",
+		help="Run executables",
+	)
+	run_parser.add_argument(
+		"--fresh",
+		action="store_true",
+		help="Force a rebuild before running",
+	)
+	run_parser.add_argument(
+		"executable",
+		help="Path or name of the executable",
+	)
+	run_parser.add_argument(
+		"executable_args",
+		nargs=argparse.REMAINDER,
+		help="Arguments passed directly to the executable",
+	)
+
+
+def setupParser() -> argparse.ArgumentParser:
+	parser = argparse.ArgumentParser(prog="zero", description="Zero build system")
+	subparsers = parser.add_subparsers(dest="command", required=True)
+
+	add_make_command(subparsers)
+	add_run_command(subparsers)
+
+	return parser
+
+
+def parseArguments(
+	parser: argparse.ArgumentParser, args: list[str] | None = None
+) -> argparse.Namespace:
+	if args is None:
+		args = sys.argv[1:]
+
+	return parser.parse_args(args)

zero/cli/main.py

@@ -0,0 +1,20 @@
+from src.zero.orchestrator import Orchestrator
+from src.zero.cli.args import setupParser, parseArguments
+
+
+def main():
+	parser = setupParser()
+	args = parseArguments(parser)
+
+	orchestrator = Orchestrator()
+
+	if args.command == "make":
+		if len(args.target) == 0:
+			orchestrator.makeBuild(fresh=args.fresh)
+		else:
+			orchestrator.makeTargets(args.target, fresh=args.fresh)
+
+	elif args.command == "run":
+		orchestrator.runExecutable(args.executable, args.executable_args, fresh=args.fresh)
+		
+

zero/compilers/__init__.py

@@ -0,0 +1,6 @@
+from .base import BaseCompiler
+
+from .gcc import GccCompiler
+from .gxx import GxxCompiler
+from .clang import ClangCompiler
+from .clangxx import ClangxxCompiler

zero/compilers/base.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class BaseCompiler(ABC):
+	"""
+	Base class for Compilers utilizing pathlib.Path objects.
+	"""
+
+	def __init__(self) -> None:
+		super().__init__()
+
+
+	@abstractmethod
+	def getDependencies(self, filepath: Path, *, include_dirs: list[Path] = []) -> list[Path]:
+		pass
+
+
+	@abstractmethod
+	def buildFile(self, filepath: Path, outfile: Path, *, for_shared = False, include_dirs: list[Path] = [], arguments: list[str] = []) -> None:  
+		pass
+	
+
+	@abstractmethod
+	def buildStaticLib(self, objects: list[Path], outfile: Path) -> None:  
+		pass
+
+
+	@abstractmethod
+	def buildSharedLib(self, objects: list[Path], libraries: list[Path], outfile: Path) -> None:  
+		pass
+
+
+	@abstractmethod
+	def buildExecutable(self, objects: list[Path], libraries: list[Path], outfile: Path) -> None:  
+		pass

zero/compilers/clang.py

@@ -0,0 +1,7 @@
+from .gcc import GccCompiler
+
+class ClangCompiler(GccCompiler):
+
+	def __init__(self) -> None:
+		super().__init__()
+		self.compiler_binary = self.linker_binary = "clang"

zero/compilers/clangxx.py

@@ -0,0 +1,7 @@
+from .gcc import GccCompiler
+
+class ClangxxCompiler(GccCompiler):
+
+	def __init__(self) -> None:
+		super().__init__()
+		self.compiler_binary = self.linker_binary = "clang++"