nomen-lang 0.0.1

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "nomen-lang",
+	"version": "0.0.1",
+	"description": "The CLI for the Nomen programming language.",
+	"keywords": [],
+	"license": "ISC",
+	"author": "",
+	"bin": {
+		"nomen": "dist/index.mjs"
+	},
+	"type": "module",
+	"scripts": {
+		"build": "vp pack",
+		"dev": "vp pack --watch",
+		"test": "vp test",
+		"check": "vp check",
+		"format": "vp check --fix",
+		"prepare": "vp config",
+		"go": "tsx src/index.ts",
+		"register": "pnpm build && pnpm add -g ."
+	},
+	"dependencies": {
+		"chokidar": "^5.0.0",
+		"yargs": "^18.0.0"
+	},
+	"devDependencies": {
+		"@types/node": "^26.1.1",
+		"@types/yargs": "^17.0.35",
+		"tsx": "^4.23.1",
+		"typescript": "^7.0.2",
+		"vite-plus": "catalog:",
+		"vitest": "catalog:"
+	}
+}

package/src/format_errors.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+
+import type CompileError from "../../src/types/CompileError.ts";
+
+interface FileMarker {
+	abs_path: string;
+	joined_line: number;
+}
+
+// Scan the joined source for `// file://<abs path>` headers inserted by join(),
+// recording the 1-based joined-source line number each header sits on.
+function find_file_markers(source: string): FileMarker[] {
+	const markers: FileMarker[] = [];
+	let line = 1;
+	let i = 0;
+	while (i < source.length) {
+		const nl = source.indexOf("\n", i);
+		const end = nl === -1 ? source.length : nl;
+		const match = source.slice(i, end).match(/^\/\/ file:\/\/(.+)$/);
+		if (match) markers.push({ abs_path: match[1], joined_line: line });
+		if (nl === -1) break;
+		line += 1;
+		i = nl + 1;
+	}
+	return markers;
+}
+
+// Width of the token an error points at, so the caret can underline the whole
+// identifier rather than a single column. Falls back to 1.
+function token_width(line_text: string, start: number): number {
+	let width = 0;
+	while (start + width < line_text.length && /\w/.test(line_text[start + width])) {
+		width += 1;
+	}
+	return width || 1;
+}
+
+const TAB_WIDTH = 4;
+
+// Visual column (0-based) for a 1-based char column, expanding tabs.
+function visual_start(line_text: string, col: number): number {
+	let v = 0;
+	for (let k = 0; k < col - 1 && k < line_text.length; k++) {
+		v += line_text[k] === "\t" ? TAB_WIDTH : 1;
+	}
+	return v;
+}
+
+export default function render_errors(source: string, errors: CompileError[]): string {
+	const lines = source.split("\n");
+	const markers = find_file_markers(source);
+
+	const blocks: string[] = [];
+	for (const error of errors) {
+		const line_text = lines[error.line - 1] ?? "";
+
+		// Map the joined-source line back to the originating file + in-file line.
+		let rel_path = "";
+		let file_line = error.line;
+		for (let m = markers.length - 1; m >= 0; m--) {
+			if (markers[m].joined_line < error.line) {
+				file_line = error.line - markers[m].joined_line;
+				rel_path = path.relative(process.cwd(), markers[m].abs_path) || markers[m].abs_path;
+				break;
+			}
+		}
+
+		const gutter = " ".repeat(String(file_line).length);
+		const col = Math.max(1, error.column);
+		const display_line = line_text.replace(/\t/g, " ".repeat(TAB_WIDTH));
+		const squiggle = "~".repeat(token_width(line_text, col - 1));
+
+		blocks.push(
+			[
+				`Error: ${error.message}`,
+				` File: ${rel_path}:${file_line}:${col}`,
+				`${gutter} |`,
+				`${file_line} | ${display_line}`,
+				`${gutter} | ${" ".repeat(visual_start(line_text, col))}${squiggle}`,
+			].join("\n"),
+		);
+	}
+
+	const label = errors.length === 1 ? "error" : "errors";
+	return `\n${blocks.join("\n\n")}\n\n${errors.length} ${label} found.\n`;
+}

package/src/index.ts

@@ -0,0 +1,281 @@
+#! /usr/bin/env node
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+import chokidar from "chokidar";
+import { hideBin } from "yargs/helpers";
+import yargs from "yargs/yargs";
+
+import build, { default_platform } from "../../src/build.ts";
+import join from "../../src/join.ts";
+import { get_library } from "../../src/lib.ts";
+import parse from "../../src/parse.ts";
+import render_errors from "./format_errors.ts";
+import type Config from "./types/Config.ts";
+
+const SUPPORTED_EXTENSION = ".nm";
+
+console.log("\n~ NOMEN ~\n");
+
+const options = yargs(hideBin(process.argv))
+	.usage("Usage: nomen --in [file/folder]")
+	.option("in", {
+		alias: "i",
+		describe: "Input file or folder",
+		type: "string",
+	})
+	.option("out", {
+		alias: "o",
+		describe: "Output file",
+		type: "string",
+	})
+	.option("config", {
+		alias: "c",
+		describe: "The path to a config file",
+		type: "string",
+	})
+	.option("watch", {
+		alias: "w",
+		describe: "Whether to watch for file changes",
+		type: "boolean",
+	})
+	.option("arch", {
+		alias: "a",
+		describe: "Target architecture (aarch64 or c)",
+		type: "string",
+		default: "aarch64",
+	})
+	.option("platform", {
+		alias: "p",
+		describe: "Target platform (macos, ios, linux, android, windows, web)",
+		type: "string",
+	})
+	.option("lib", {
+		alias: "l",
+		describe: "Path to System library directory (containing package.jsonc)",
+		type: "string",
+	})
+	.option("audit", {
+		describe: "Whether to audit the generated program for memory issues",
+		type: "boolean",
+	})
+	.option("audit-runtime", {
+		describe: "Path to audit_runtime.c, linked in when --audit is set",
+		type: "string",
+	})
+	.help(true)
+	.check((argv) => {
+		if (!argv._.length && !argv.in) {
+			throw new Error("Missing required argument: in");
+		}
+		return true;
+	})
+	.parseSync();
+
+try {
+	if (!options.in) {
+		process.exit(0);
+	}
+
+	if (fs.existsSync(options.in)) {
+		let config: Config = { arch: "aarch64", platform: default_platform() };
+		// Load the config from a file
+		if (options.config && fs.existsSync(options.config)) {
+			config = JSON.parse(fs.readFileSync(options.config, "utf-8"));
+		}
+		// Overwrite with args
+		if (options.arch) config.arch = options.arch as "aarch64" | "c";
+		if (options.platform) config.platform = options.platform as string;
+		if (options.lib) config.lib = options.lib;
+		if (options.audit) config.audit = options.audit;
+		if (options["audit-runtime"]) config.audit_runtime = options["audit-runtime"];
+
+		// Is the --in path a folder
+		if (fs.lstatSync(options.in).isDirectory()) {
+			// Loop through files in the folder
+			//processFolder(options.in);
+			if (options.watch) {
+				watchPath(options.in, config);
+			} else {
+				processFolder(options.in, config);
+			}
+		} else {
+			// Process the supplied file
+			const extname = path.extname(options.in);
+			if (shouldProcessFile(options.in)) {
+				//processFile(options.in);
+				// NOTE: We get add notifications for all watched files immediately
+				// TODO: Is this the case on Windows etc too?
+				if (options.watch) {
+					watchPath(options.in, config);
+				} else {
+					processFile(options.in, config);
+				}
+			} else {
+				console.log("Unsupported file type: " + extname);
+			}
+		}
+	} else {
+		console.log("Path not found: " + options.in);
+	}
+} catch (err) {
+	console.log("UH", err);
+}
+
+function resolve_lib(file_path: string): string | undefined {
+	let dir = path.dirname(path.resolve(file_path));
+	for (let i = 0; i < 20; i++) {
+		const config_path = path.join(dir, "package.jsonc");
+		if (fs.existsSync(config_path)) {
+			try {
+				const raw = fs.readFileSync(config_path, "utf8");
+				const json = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+				const parsed = JSON.parse(json);
+				if (parsed.imports?.System) {
+					return path.resolve(dir, parsed.imports.System);
+				}
+			} catch {
+				// ignore malformed package.jsonc and keep searching
+			}
+		}
+		const lib_config = path.join(dir, "core", "package.jsonc");
+		if (fs.existsSync(lib_config)) return path.join(dir, "core");
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return undefined;
+}
+
+function resolve_audit_runtime(config: Config, input_path: string): string | undefined {
+	if (config.audit_runtime) {
+		const explicit = path.resolve(config.audit_runtime);
+		return fs.existsSync(explicit) ? explicit : undefined;
+	}
+	let dir = path.dirname(input_path);
+	for (let i = 0; i < 20; i++) {
+		const candidate = path.join(dir, "src", "audit_runtime.c");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return undefined;
+}
+
+function compile_audit_runtime(config: Config, input_path: string, buildDir: string): string {
+	const runtime_src = resolve_audit_runtime(config, input_path);
+	if (!runtime_src) {
+		throw new Error(
+			"Audit enabled but audit_runtime.c was not found. Pass --audit-runtime <path/to/audit_runtime.c>.",
+		);
+	}
+	const audit_obj = path.join(buildDir, "audit_runtime.o");
+	execSync(`clang -c ${runtime_src} -o ${audit_obj}`);
+	return audit_obj;
+}
+
+function watchPath(p: string, config: Config) {
+	chokidar.watch(p).on("all", (event, filePath) => {
+		if (shouldProcessFile(filePath)) {
+			processFile(filePath, config);
+		}
+	});
+}
+
+function processFolder(folder: string, config: Config) {
+	const dir = fs.opendirSync(folder);
+	let dirent;
+	while ((dirent = dir.readSync()) !== null) {
+		if (shouldProcessFile(dirent.name)) {
+			processFile(path.join(folder, dirent.name), config);
+			// @ts-ignore
+			let _ = fs.watch;
+		}
+	}
+	dir.closeSync();
+}
+
+function shouldProcessFile(filename: string) {
+	return path.extname(filename) === SUPPORTED_EXTENSION;
+}
+
+function processFile(filename: string, config: Config) {
+	console.log("Processing", filename);
+
+	const arch = config.arch || "aarch64";
+	const platform = config.platform || default_platform();
+
+	const resolved = path.resolve(filename);
+	if (!config.lib) {
+		config.lib = resolve_lib(resolved);
+	}
+
+	let startTime = performance.now();
+
+	let input = join(path.resolve(filename), config.lib);
+	const library = config.lib ? get_library(config.lib) : undefined;
+	const parsed = parse(input, library);
+	// TODO: If verbose flag
+	// console.log("Parsed");
+
+	let errors = parsed.errors;
+	const ok = !errors.length;
+
+	if (!ok) {
+		console.log(render_errors(input, errors));
+		return;
+	}
+
+	// TODO: If verbose flag
+	// console.log("Built");
+	const result = build(parsed.root, { arch, platform, audit: config.audit });
+
+	if (result.errors && result.errors.length > 0) {
+		console.log(render_errors(input, result.errors));
+		return;
+	}
+
+	const dir = path.dirname(filename);
+	const basename = path.basename(filename, ".nm");
+	const buildDir = path.join(dir, "build");
+	if (!fs.existsSync(buildDir)) {
+		fs.mkdirSync(buildDir, { recursive: true });
+	}
+	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
+	const headerfile = path.join(buildDir, "main.h");
+	const codefile = path.join(buildDir, basename + ext);
+	const outfile = path.join(buildDir, basename);
+	fs.writeFileSync(headerfile, result.headers);
+	fs.writeFileSync(codefile, result.code);
+
+	let companionfile: string | undefined;
+	if (result.companion) {
+		const comp_ext = platform === "macos" || platform === "ios" ? ".m" : ".c";
+		companionfile = path.join(buildDir, basename + "_companion" + comp_ext);
+		fs.writeFileSync(companionfile, result.companion);
+	}
+
+	const compileTime = performance.now();
+	console.log(`Created ${codefile} in ${(compileTime - startTime).toFixed(2)}ms`);
+	console.log("");
+
+	startTime = performance.now();
+
+	const audit_obj = config.audit ? compile_audit_runtime(config, resolved, buildDir) : undefined;
+	let link_inputs = codefile;
+	if (companionfile) link_inputs += ` ${companionfile}`;
+	if (audit_obj) link_inputs += ` ${audit_obj}`;
+	const framework_flags =
+		platform === "macos" || platform === "ios"
+			? " -framework CoreGraphics -framework Foundation -framework AppKit -lobjc"
+			: "";
+	execSync(`clang -o ${outfile} ${link_inputs}${framework_flags}`);
+	execSync(outfile, { stdio: "inherit" });
+
+	const runTime = performance.now();
+	console.log("");
+	console.log("");
+	console.log(`Completed in ${(runTime - startTime).toFixed(2)}ms`);
+}

package/src/types/Config.ts

@@ -0,0 +1,7 @@
+export default interface Config {
+	arch?: "c" | "aarch64";
+	platform?: string;
+	lib?: string;
+	audit?: boolean;
+	audit_runtime?: string;
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "esnext",
+		"lib": ["es2023"],
+		"moduleDetection": "force",
+		"module": "nodenext",
+		"moduleResolution": "nodenext",
+		"resolveJsonModule": true,
+		"types": ["node"],
+		"strict": true,
+		"noUnusedLocals": true,
+		"declaration": true,
+		"noEmit": true,
+		"allowImportingTsExtensions": true,
+		"esModuleInterop": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"skipLibCheck": true
+	},
+	"include": ["src"]
+}