fax-lang 0.0.1 → 0.0.2

package/README.md

@@ -52,6 +52,15 @@ The compiler automatically analyzes access patterns to decide whether data shoul
 - **LLVM** (llc & clang v14/18)
 
 ### Installation
+
+You can install the Fax-lang compiler directly from **NPM**:
+
+```bash
+npm install -g fax-lang
+```
+
+Or for local development:
+
 ```bash
 git clone https://github.com/Luvion1/Fax-lang.git
 cd Fax-lang
@@ -62,13 +71,16 @@ npm install
 
 ## 🚀 Usage
 
-### Compiling Programs
+### Using the global command
+If installed via NPM:
+```bash
+fax build examples/mvp.fx
+```
+
+### Compiling Programs (Local)
 ```bash
 # Build a binary from a .fx file
 npm run dev build examples/mvp.fx
-
-# Execute the output
-./examples/mvp
 ```
 
 ### AST Visualization

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "fax-lang",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "The Fax Programming Language Reference Implementation",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "src/index.ts",
   "bin": {
-    "fax": "./dist/index.js"
+    "fax": "./src/index.ts"
   },
   "scripts": {
     "dev": "node --loader ts-node/esm src/index.ts",
@@ -34,12 +34,12 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3",
     "vitest": "^1.2.1"
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "commander": "^11.1.0"
+    "commander": "^11.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
   }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings
 
 import fs from 'node:fs';
 import path from 'node:path';

package/CNAME

@@ -1 +0,0 @@
-fax-lang.js.org

package/dist/index.js

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { Lexer } from './modules/lexer/index.js';
-import { Parser } from './modules/parser/index.js';
-import { CodeGenerator } from './modules/codegen/index.js';
-import { SemanticChecker } from './modules/analysis/checker.js';
-function findTool(names) {
-    for (const name of names) {
-        try {
-            const res = spawnSync(name, ['--version'], { stdio: 'ignore' });
-            if (res.status === 0)
-                return name;
-        }
-        catch (e) {
-            continue;
-        }
-    }
-    return null;
-}
-async function main() {
-    const args = process.argv.slice(2);
-    const command = args[0];
-    if (args.length < 2 || (command !== 'ast' && command !== 'build')) {
-        console.log("Fax-lang Compiler v0.0.1");
-        console.log("Usage: fax build <file.fx>");
-        process.exit(1);
-    }
-    const file = args[1];
-    const filePath = path.resolve(process.cwd(), file);
-    const projectRoot = process.cwd();
-    if (!filePath.startsWith(projectRoot)) {
-        console.error(`Error: Access denied to path: ${filePath}`);
-        process.exit(1);
-    }
-    if (!fs.existsSync(filePath)) {
-        console.error(`Error: File not found: ${filePath}`);
-        process.exit(1);
-    }
-    const source = fs.readFileSync(filePath, 'utf-8');
-    const baseName = path.basename(file, '.fx');
-    const outputDir = path.dirname(filePath);
-    const outputBin = path.join(outputDir, baseName);
-    try {
-        const lexer = new Lexer(source);
-        const parser = new Parser(lexer);
-        const ast = parser.parseProgram();
-        if (parser.errors.length > 0) {
-            parser.errors.forEach(err => console.error(err));
-            process.exit(1);
-        }
-        if (command === 'ast') {
-            console.log(JSON.stringify(ast, (k, v) => (k === 'token' ? undefined : v), 2));
-            return;
-        }
-        const checker = new SemanticChecker();
-        checker.check(ast);
-        console.log(`\n[Fax] Compiling ${file}...`);
-        const codegen = new CodeGenerator(baseName);
-        const llvmIR = codegen.generate(ast);
-        const tempLl = path.join(outputDir, `.${baseName}.tmp.ll`);
-        const tempObj = path.join(outputDir, `.${baseName}.tmp.o`);
-        fs.writeFileSync(tempLl, llvmIR);
-        const llcBin = findTool(['llc-18', 'llc-14', 'llc']);
-        const clangBin = findTool(['clang-18', 'clang-14', 'clang']);
-        if (llcBin && clangBin) {
-            const llc = spawnSync(llcBin, ['-O3', '-filetype=obj', '-relocation-model=pic', '-o', tempObj, tempLl], { stdio: 'inherit' });
-            if (llc.status !== 0)
-                throw new Error("llc failed");
-            const clang = spawnSync(clangBin, ['-O3', '-fuse-ld=lld', '-o', outputBin, tempObj], { stdio: 'inherit' });
-            if (clang.status !== 0)
-                throw new Error("clang failed");
-            fs.unlinkSync(tempLl);
-            fs.unlinkSync(tempObj);
-            console.log(`✅ Build Successful: ${outputBin}`);
-        }
-        else {
-            console.log("⚠️ Toolchain missing, IR saved.");
-        }
-    }
-    catch (error) {
-        const { ErrorReporter } = await import('./shared/logger/error-reporter.js');
-        ErrorReporter.report(error, source, file);
-        process.exit(1);
-    }
-}
-main();

package/dist/modules/analysis/checker.js

@@ -1,142 +0,0 @@
-import { MemoryManager } from "./memory-manager.js";
-import { NodeType } from "../parser/ast/nodes.js";
-import { CompilerError } from "../../shared/errors/compiler-error.js";
-import { Logger } from "../../shared/logger/index.js";
-export class SemanticChecker {
-    memManager = new MemoryManager();
-    functions = new Set();
-    check(ast) {
-        Logger.info("Validating Fax-lang Memory Rules...");
-        for (const stmt of ast.statements) {
-            if (stmt.type === NodeType.FunctionDeclaration) {
-                this.functions.add(stmt.name.value);
-            }
-        }
-        for (const stmt of ast.statements) {
-            this.analyzeStatement(stmt);
-        }
-        Logger.success("All Memory Rules Satisfied.");
-    }
-    analyzeStatement(stmt) {
-        if (!stmt)
-            return;
-        switch (stmt.type) {
-            case NodeType.LetStatement:
-                const type = stmt.dataType || "i32";
-                this.memManager.analyzePlacement(stmt.name.value, type, 32, false, stmt.isMut || false);
-                this.analyzeExpression(stmt.value);
-                break;
-            case NodeType.FunctionDeclaration:
-                this.memManager.enterScope();
-                if (stmt.params) {
-                    for (const p of stmt.params) {
-                        const pType = p.dataType || "i32";
-                        this.memManager.analyzePlacement(p.value, pType, 32, false, false);
-                    }
-                }
-                this.analyzeStatement(stmt.body);
-                this.memManager.exitScope();
-                break;
-            case "ShadowStatement":
-                const source = stmt.value.value;
-                const shadowName = stmt.name.value;
-                if (source === shadowName) {
-                    throw new CompilerError("E005", `cannot shadow variable \`${source}\` with itself`, stmt.token.line, stmt.token.column, undefined, `Shadowing requires a new name to create a view. Try: \`shadow ${source}_view = ${source}\``);
-                }
-                if (!this.memManager.getMetadata(source)) {
-                    throw new CompilerError("E003", `cannot shadow undefined variable \`${source}\``, stmt.token.line, stmt.token.column, undefined, `Variable \`${source}\` must be declared in the current scope before it can be shadowed.`);
-                }
-                this.memManager.createShadow(source, stmt.name.value);
-                break;
-            case "ConstStatement":
-                this.memManager.analyzePlacement(stmt.name.value, stmt.dataType || "i32", 32, true, false, true);
-                break;
-            case NodeType.BlockStatement:
-                this.memManager.enterScope();
-                for (const s of stmt.statements) {
-                    this.analyzeStatement(s);
-                }
-                this.memManager.exitScope();
-                break;
-            case NodeType.StateMachine:
-                const validStates = new Set(stmt.states.map((s) => s.name.value));
-                const checkTransition = (t) => {
-                    if (t.target && !validStates.has(t.target)) {
-                        throw new CompilerError("E004", `transition targets undefined state \`${t.target}\``, t.token.line, t.token.column, undefined, `The state machine \`${stmt.name.value}\` does not have a state named \`${t.target}\`.`);
-                    }
-                    this.memManager.enterScope();
-                    this.analyzeStatement(t.body);
-                    this.memManager.exitScope();
-                };
-                stmt.states.forEach((state) => {
-                    this.memManager.enterScope();
-                    state.transitions.forEach((t) => checkTransition(t));
-                    this.memManager.exitScope();
-                });
-                if (stmt.anyTransitions) {
-                    stmt.anyTransitions.forEach((t) => checkTransition(t));
-                }
-                break;
-            case NodeType.ReturnStatement:
-                this.analyzeExpression(stmt.returnValue);
-                break;
-            case NodeType.ExpressionStatement:
-                this.analyzeExpression(stmt.expression);
-                break;
-            case "WhileStatement":
-                this.analyzeExpression(stmt.condition);
-                this.analyzeStatement(stmt.body);
-                break;
-        }
-    }
-    analyzeExpression(expr) {
-        if (!expr)
-            return;
-        switch (expr.type) {
-            case NodeType.Identifier:
-                const meta = this.memManager.getMetadata(expr.value);
-                if (!meta && !this.functions.has(expr.value)) {
-                    throw new CompilerError("E002", `use of exhausted or undefined variable \`${expr.value}\``, expr.token.line, expr.token.column, undefined, `Variable \`${expr.value}\` has no remaining Life-Force or is not defined in this scope.`);
-                }
-                if (meta) {
-                    this.memManager.decay(expr.value, "read");
-                    if (meta.lifeForce.current <= 0) {
-                        throw new CompilerError("E002", `variable \`${expr.value}\` has been exhausted`, expr.token.line, expr.token.column, undefined, "Energy depleted. Reading from this variable costs 0.02 Life-Force.");
-                    }
-                }
-                break;
-            case "AssignmentExpression":
-                const varName = expr.name.value;
-                const targetMeta = this.memManager.getMetadata(varName);
-                if (!targetMeta) {
-                    throw new CompilerError("E002", `cannot assign to undefined variable \`${varName}\``, expr.token.line, expr.token.column);
-                }
-                if (!targetMeta.isMut) {
-                    throw new CompilerError("E001", `cannot assign twice to immutable variable \`${varName}\``, expr.token.line, expr.token.column, undefined, `Make this variable mutable by writing \`let mut ${varName}\` instead of \`let ${varName}\`.`);
-                }
-                this.memManager.decay(varName, "write");
-                this.analyzeExpression(expr.value);
-                break;
-            case "IfExpression":
-                this.analyzeExpression(expr.condition);
-                this.analyzeStatement(expr.consequence);
-                if (expr.alternative) {
-                    if (expr.alternative.type === "IfExpression") {
-                        this.analyzeExpression(expr.alternative);
-                    }
-                    else {
-                        this.analyzeStatement(expr.alternative);
-                    }
-                }
-                break;
-            case NodeType.InfixExpression:
-                this.analyzeExpression(expr.left);
-                this.analyzeExpression(expr.right);
-                if (expr.operator === "&&" || expr.operator === "||") {
-                }
-                break;
-            case NodeType.IntegerLiteral:
-                break;
-        }
-    }
-}

package/dist/modules/analysis/memory-manager.js

@@ -1,76 +0,0 @@
-import { Scope } from "./scopes/scope-manager.js";
-import { Logger } from "../../shared/logger/index.js";
-export const MemoryPlacement = {
-    Stack: "Stack",
-    Heap: "Heap",
-    Hybrid: "Hybrid"
-};
-export class MemoryManager {
-    currentScope = new Scope();
-    enterScope() {
-        this.currentScope = this.currentScope.enterChild();
-    }
-    exitScope() {
-        if (this.currentScope.parent) {
-            this.currentScope = this.currentScope.parent;
-        }
-    }
-    analyzePlacement(varName, type, size, isLongLived, isMut = false, isConst = false) {
-        let placement;
-        if (size <= 64 && !isLongLived) {
-            placement = MemoryPlacement.Stack;
-        }
-        else if (size > 1024) {
-            placement = MemoryPlacement.Heap;
-        }
-        else {
-            placement = MemoryPlacement.Hybrid;
-        }
-        this.currentScope.define(varName, {
-            placement,
-            lifeForce: { current: 1.0 },
-            isShadow: false,
-            isMirror: false,
-            isMut,
-            isConst,
-            type,
-            associatedState: "Initial"
-        });
-        return placement;
-    }
-    decay(varName, type = "read") {
-        const meta = this.currentScope.lookup(varName);
-        if (meta && !meta.isConst) {
-            const rates = { read: 0.02, write: 0.08, heavy: 0.15 };
-            meta.lifeForce.current -= rates[type];
-            if (meta.lifeForce.current < 0)
-                meta.lifeForce.current = 0;
-        }
-    }
-    boost(varName, amount = 0.1) {
-        const meta = this.currentScope.lookup(varName);
-        if (meta) {
-            meta.lifeForce.current = Math.min(1.0, meta.lifeForce.current + amount);
-            Logger.debug(`${varName} life-force boosted by ${amount}`, "Rule 2");
-        }
-    }
-    updateState(varName, newState) {
-        const meta = this.currentScope.lookup(varName);
-        if (meta) {
-            meta.associatedState = newState;
-        }
-    }
-    createShadow(sourceVar, shadowVar) {
-        const sourceMeta = this.currentScope.lookup(sourceVar);
-        if (sourceMeta) {
-            this.currentScope.define(shadowVar, {
-                ...sourceMeta,
-                isShadow: true,
-                isMirror: false,
-                isMut: false
-            });
-            Logger.debug(`Shadow created: ${shadowVar} -> ${sourceVar}`, "Rule 1");
-        }
-    }
-    getMetadata(varName) { return this.currentScope.lookup(varName); }
-}

package/dist/modules/analysis/scopes/scope-manager.js

@@ -1,26 +0,0 @@
-export class Scope {
-    symbols = new Map();
-    parent = null;
-    constructor(parent = null) {
-        this.parent = parent;
-    }
-    define(name, value) {
-        if (this.symbols.has(name))
-            return false;
-        this.symbols.set(name, value);
-        return true;
-    }
-    lookup(name) {
-        let current = this;
-        while (current) {
-            const sym = current.symbols.get(name);
-            if (sym !== undefined)
-                return sym;
-            current = current.parent;
-        }
-        return null;
-    }
-    enterChild() {
-        return new Scope(this);
-    }
-}

package/dist/modules/backend/native/arm64.js

@@ -1,28 +0,0 @@
-function instr(val) {
-    const buf = Buffer.alloc(4);
-    buf.writeUInt32LE(val, 0);
-    return buf;
-}
-export class Arm64Emitter {
-    buffer = [];
-    emitSvc0() {
-        this.buffer.push(instr(0xD4000001));
-    }
-    emitMovX0(imm) {
-        if (imm > 65535) {
-            throw new Error("MVP only supports 16-bit integers for now");
-        }
-        const opcode = (0xD2800000 | (imm << 5) | 0) >>> 0;
-        this.buffer.push(instr(opcode));
-    }
-    emitMovX8(imm) {
-        if (imm > 65535) {
-            throw new Error("MVP only supports 16-bit integers for now");
-        }
-        const opcode = (0xD2800000 | (imm << 5) | 8) >>> 0;
-        this.buffer.push(instr(opcode));
-    }
-    getCode() {
-        return Buffer.concat(this.buffer);
-    }
-}

package/dist/modules/backend/native/codegen.js

@@ -1,65 +0,0 @@
-import { NodeType } from "../../parser/ast/nodes.js";
-import { Arm64Emitter } from "./arm64.js";
-import { ElfGenerator } from "./elf.js";
-export class NativeCodegen {
-    emitter;
-    varValues = new Map();
-    constructor() {
-        this.emitter = new Arm64Emitter();
-    }
-    generate(ast) {
-        for (const stmt of ast.statements) {
-            this.visitStatement(stmt);
-        }
-        this.emitter.emitMovX0(0);
-        this.emitter.emitMovX8(93);
-        this.emitter.emitSvc0();
-        const machineCode = this.emitter.getCode();
-        return ElfGenerator.generate(machineCode);
-    }
-    visitStatement(stmt) {
-        switch (stmt.type) {
-            case NodeType.LetStatement:
-                if (stmt.value.type === NodeType.IntegerLiteral) {
-                    this.varValues.set(stmt.name.value, stmt.value.value);
-                }
-                else if (stmt.value.type === NodeType.InfixExpression) {
-                    const val = this.evaluateConstantExpr(stmt.value);
-                    this.varValues.set(stmt.name.value, val);
-                }
-                break;
-            case NodeType.ReturnStatement:
-                const val = this.evaluateExpression(stmt.returnValue);
-                this.emitter.emitMovX0(val);
-                this.emitter.emitMovX8(93);
-                this.emitter.emitSvc0();
-                break;
-        }
-    }
-    evaluateExpression(expr) {
-        if (expr.type === NodeType.IntegerLiteral) {
-            return expr.value;
-        }
-        else if (expr.type === NodeType.Identifier) {
-            const val = this.varValues.get(expr.value);
-            if (val === undefined)
-                throw new Error(`Variable ${expr.value} not found or not constant`);
-            return val;
-        }
-        else if (expr.type === NodeType.InfixExpression) {
-            return this.evaluateConstantExpr(expr);
-        }
-        return 0;
-    }
-    evaluateConstantExpr(expr) {
-        const left = this.evaluateExpression(expr.left);
-        const right = this.evaluateExpression(expr.right);
-        switch (expr.operator) {
-            case '+': return left + right;
-            case '-': return left - right;
-            case '*': return left * right;
-            case '/': return Math.floor(left / right);
-            default: return 0;
-        }
-    }
-}

package/dist/modules/backend/native/elf.js

@@ -1,57 +0,0 @@
-export const ELF_HEADER_SIZE = 0x40;
-export const PROGRAM_HEADER_SIZE = 0x38;
-export const BASE_ADDRESS = 0x400000;
-export function writeU8(buf, val, offset) {
-    buf.writeUInt8(val, offset);
-}
-export function writeU16(buf, val, offset) {
-    buf.writeUInt16LE(val, offset);
-}
-export function writeU32(buf, val, offset) {
-    buf.writeUInt32LE(val, offset);
-}
-export function writeU64(buf, val, offset) {
-    buf.writeBigUInt64LE(val, offset);
-}
-export class ElfGenerator {
-    static generate(code) {
-        const fileSize = ELF_HEADER_SIZE + PROGRAM_HEADER_SIZE + code.length;
-        const buf = Buffer.alloc(fileSize);
-        writeU8(buf, 0x7F, 0);
-        writeU8(buf, 0x45, 1);
-        writeU8(buf, 0x4C, 2);
-        writeU8(buf, 0x46, 3);
-        writeU8(buf, 2, 4);
-        writeU8(buf, 1, 5);
-        writeU8(buf, 1, 6);
-        writeU8(buf, 0, 7);
-        writeU8(buf, 0, 8);
-        writeU16(buf, 2, 16);
-        writeU16(buf, 183, 18);
-        writeU32(buf, 1, 20);
-        const entryPoint = BigInt(BASE_ADDRESS + ELF_HEADER_SIZE + PROGRAM_HEADER_SIZE);
-        writeU64(buf, entryPoint, 24);
-        writeU64(buf, BigInt(ELF_HEADER_SIZE), 32);
-        writeU64(buf, BigInt(0), 40);
-        writeU32(buf, 0, 48);
-        writeU16(buf, ELF_HEADER_SIZE, 52);
-        writeU16(buf, PROGRAM_HEADER_SIZE, 54);
-        writeU16(buf, 1, 56);
-        writeU16(buf, 0, 58);
-        writeU16(buf, 0, 60);
-        writeU16(buf, 0, 62);
-        const phOffset = ELF_HEADER_SIZE;
-        writeU32(buf, 1, phOffset + 0);
-        writeU32(buf, 7, phOffset + 4);
-        writeU64(buf, BigInt(0), phOffset + 8);
-        writeU64(buf, BigInt(BASE_ADDRESS), phOffset + 16);
-        writeU64(buf, BigInt(BASE_ADDRESS), phOffset + 24);
-        const totalSize = BigInt(fileSize);
-        writeU64(buf, totalSize, phOffset + 32);
-        writeU64(buf, totalSize, phOffset + 40);
-        writeU64(buf, BigInt(0x1000), phOffset + 48);
-        const codeOffset = ELF_HEADER_SIZE + PROGRAM_HEADER_SIZE;
-        code.copy(buf, codeOffset);
-        return buf;
-    }
-}