darijacode 0.2.0

package/dist/compiler/codegen/stmts.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = statementGen;
+const errors_1 = require("../errors");
+function statementGen(codegen, stmt, scope) {
+    switch (stmt.type) {
+        case "VariableDeclaration": {
+            if (!stmt.init) {
+                throw new errors_1.CodegenError(`'${stmt.name}' khas t3ta liha 9ima`, stmt.pos.line, stmt.pos.column);
+            }
+            const type = stmt.typeAnnotation ?? codegen.inferType(stmt.init, scope);
+            scope.declare(stmt.name, type);
+            if (!type.d && stmt.init.type === "ArrayExpression") {
+                const values = stmt.init.elements.map((e) => codegen.genExpression(e, scope));
+                codegen.emit(`${codegen.cType(type)} ${stmt.name}[] = {${values.join(", ")}};`);
+            }
+            else {
+                codegen.emit(`${codegen.cType(type)} ${stmt.name} = ${codegen.genExpression(stmt.init, scope)};`);
+            }
+            return;
+        }
+        case "FunctionDeclaration":
+            // handled at the top level; nested function declarations aren't supported yet
+            throw new errors_1.CodegenError("ddawal lmtad5lin mmd3ominch l7ad sa3a", stmt.pos.line, stmt.pos.column);
+        case "ReturnStatement":
+            codegen.emit(stmt.argument ? `return ${codegen.genExpression(stmt.argument, scope)};` : "return;");
+            return;
+        case "IfStatement": {
+            codegen.emit(`if (${codegen.genExpression(stmt.condition, scope)}) {`);
+            codegen.genNestedBlock(stmt.consequent, scope);
+            for (const branch of stmt.elseIfs) {
+                codegen.emit(`} else if (${codegen.genExpression(branch.condition, scope)}) {`);
+                codegen.genNestedBlock(branch.consequent, scope);
+            }
+            if (stmt.alternate) {
+                codegen.emit(`} else {`);
+                codegen.genNestedBlock(stmt.alternate, scope);
+            }
+            codegen.emit(`}`);
+            return;
+        }
+        case "WhileStatement":
+            codegen.emit(`while (${codegen.genExpression(stmt.condition, scope)}) {`);
+            codegen.genNestedBlock(stmt.body, scope);
+            codegen.emit(`}`);
+            return;
+        case "ForStatement": {
+            const forScope = scope.child();
+            let initStr = "";
+            if (stmt.init?.type === "VariableDeclaration") {
+                if (!stmt.init.init) {
+                    throw new errors_1.CodegenError(`'${stmt.init.name}' khas t3ta liha 9ima`, stmt.pos.line, stmt.pos.column);
+                }
+                const type = stmt.init.typeAnnotation ?? codegen.inferType(stmt.init.init, forScope);
+                forScope.declare(stmt.init.name, type);
+                initStr = `${codegen.cType(type)} ${stmt.init.name} = ${codegen.genExpression(stmt.init.init, forScope)}`;
+            }
+            else if (stmt.init?.type === "ExpressionStatement") {
+                initStr = codegen.genExpression(stmt.init.expression, forScope);
+            }
+            const condStr = stmt.condition ? codegen.genExpression(stmt.condition, forScope) : "";
+            const updateStr = stmt.update ? codegen.genExpression(stmt.update, forScope) : "";
+            codegen.emit(`for (${initStr}; ${condStr}; ${updateStr}) {`);
+            codegen.genNestedBlock(stmt.body, forScope);
+            codegen.emit(`}`);
+            return;
+        }
+        case "BreakStatement":
+            codegen.emit("break;");
+            return;
+        case "ContinueStatement":
+            codegen.emit("continue;");
+            return;
+        case "BlockStatement":
+            codegen.emit("{");
+            codegen.genNestedBlock(stmt, scope);
+            codegen.emit("}");
+            return;
+        case "PrintStatement": {
+            const type = codegen.inferType(stmt.argument, scope);
+            codegen.emit(codegen.genPrint(stmt.argument, type, scope));
+            return;
+        }
+        case "ExpressionStatement":
+            codegen.emit(`${codegen.genExpression(stmt.expression, scope)};`);
+            return;
+        default:
+            throw new errors_1.CodegenError(`'${stmt.type}' ba9i mmd3omach`, stmt.pos.line, stmt.pos.column);
+    }
+}

package/dist/compiler/codegen/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compiler/compiler.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+exports.checkOnly = checkOnly;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const index_1 = require("./checker/index");
+const codegen_1 = require("./codegen/codegen");
+const errors_1 = require("./errors");
+function compile(sourcePath, options = {}) {
+    const source = fs.readFileSync(sourcePath, "utf8");
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse();
+    new index_1.Checker().check(ast);
+    const cSource = new codegen_1.Codegen().generate(ast);
+    const outputPath = options.outputPath ?? defaultOutputPath(sourcePath);
+    const cFile = writeCFile(sourcePath, outputPath, cSource, options.keepCFile ?? false);
+    try {
+        compileCFile(cFile, outputPath, options.cc);
+    }
+    finally {
+        if (!options.keepCFile) {
+            fs.rmSync(cFile, { force: true });
+        }
+    }
+    return {
+        binaryPath: outputPath,
+        cFilePath: options.keepCFile ? cFile : null
+    };
+}
+function checkOnly(sourcePath) {
+    const source = fs.readFileSync(sourcePath, "utf8");
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse();
+    new index_1.Checker().check(ast);
+}
+function defaultOutputPath(sourcePath) {
+    const dir = path.dirname(sourcePath);
+    const name = path.basename(sourcePath, path.extname(sourcePath));
+    return path.join(dir, name);
+}
+function writeCFile(sourcePath, outputPath, code, keep) {
+    const cFile = keep
+        ? `${outputPath}.c`
+        : path.join(os.tmpdir(), `${path.basename(sourcePath)}-${Date.now()}.c`);
+    fs.writeFileSync(cFile, code);
+    return cFile;
+}
+function compileCFile(cFile, output, preferred) {
+    const compilers = preferred
+        ? [preferred]
+        : ["clang", "gcc"];
+    let last;
+    for (const cc of compilers) {
+        try {
+            (0, child_process_1.execFileSync)(cc, [cFile, "-lm", "-o", output], { stdio: "pipe" });
+            return;
+        }
+        catch (err) {
+            last = err;
+        }
+    }
+    const stderr = last &&
+        typeof last === "object" &&
+        "stderr" in last
+        ? String(last.stderr)
+        : String(last);
+    throw new errors_1.DarijaError({
+        code: "DCE-1",
+        stage: "codegen",
+        message: "C compiler failed.",
+        location: {
+            line: 0,
+            column: 0
+        },
+        hint: stderr
+    });
+}

package/dist/compiler/errors.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarijaError = exports.CodegenError = void 0;
+exports.printDarijaError = printDarijaError;
+class CodegenError extends Error {
+    constructor(message, line = -1, column = -1) {
+        super();
+        throw new DarijaError({
+            code: "DCE-0",
+            stage: "codegen",
+            message: `DarijaCode Codegen Error: ${message} at ${line}:${column}`,
+            location: {
+                line: line,
+                column: column
+            }
+        });
+    }
+}
+exports.CodegenError = CodegenError;
+class DarijaError extends Error {
+    stage;
+    code;
+    location;
+    hint;
+    constructor(options) {
+        super(options.message);
+        this.name = "DarijaError";
+        this.stage = options.stage;
+        this.code = options.code;
+        this.location = options.location;
+        this.hint = options.hint;
+    }
+}
+exports.DarijaError = DarijaError;
+const colors = {
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[36m",
+    gray: "\x1b[90m",
+    reset: "\x1b[0m",
+};
+function printDarijaError(err, file, source) {
+    const { stage, code, location, message, hint } = err;
+    console.error(`${colors.red}DarijaCode error${colors.reset}[${colors.gray}${stage}:${code}${colors.reset}] ${message}`);
+    console.error(`${colors.gray}-->${colors.reset} ${file}:${location.line}:${location.column}`);
+    if (source) {
+        const lines = source.split("\n");
+        const line = lines[location.line - 1];
+        if (line) {
+            console.error(`${colors.blue}${location.line} |${colors.reset} ${line}`);
+            console.error(`${colors.blue}  |${colors.reset} ` +
+                " ".repeat(location.column - 1) +
+                `${colors.red}^${colors.reset}`);
+        }
+    }
+    if (hint) {
+        console.error(`${colors.yellow}jrb/chof${colors.reset}: ${hint}`);
+    }
+}

package/dist/compiler/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+exports.default = execute;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const compiler_1 = require("./compiler");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compiler_1.compile; } });
+const errors_1 = require("./errors");
+function execute(option, file) {
+    switch (option) {
+        case "check":
+            (0, compiler_1.checkOnly)(file);
+            break;
+        case "build":
+            compileItForMe(file);
+            break;
+        case "run": {
+            const binpath = compileItForMe(file);
+            (0, child_process_1.execFileSync)(binpath.binaryPath, { stdio: "inherit" });
+        }
+    }
+}
+function compileItForMe(file) {
+    try {
+        return (0, compiler_1.compile)(file);
+    }
+    catch (err) {
+        if (err instanceof errors_1.DarijaError) {
+            const source = fs.readFileSync(file, "utf-8");
+            (0, errors_1.printDarijaError)(err, file, source);
+            process.exit(1);
+        }
+        throw err;
+    }
+}

package/dist/compiler/lexer.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+const tokens_1 = require("./tokens");
+const errors_1 = require("./errors");
+const keywords = {
+    dir: tokens_1.TokenType.DIR,
+    khli: tokens_1.TokenType.KHLI,
+    kteb: tokens_1.TokenType.KTEB,
+    dalla: tokens_1.TokenType.FN,
+    raj3: tokens_1.TokenType.RAJ3,
+    ila: tokens_1.TokenType.ILA,
+    awla: tokens_1.TokenType.AWLA,
+    wla: tokens_1.TokenType.WLA,
+    mahd: tokens_1.TokenType.MAHD,
+    dwr: tokens_1.TokenType.DWR,
+    qta3: tokens_1.TokenType.QTA3,
+    kml: tokens_1.TokenType.KAML,
+    class: tokens_1.TokenType.CLASS,
+    lbnnay: tokens_1.TokenType.DIRFLBLASA,
+    wratmn: tokens_1.TokenType.WRAATMN,
+    sa7i7: tokens_1.TokenType.TRUE,
+    ghalat: tokens_1.TokenType.FALSE,
+    khawi: tokens_1.TokenType.NULL,
+};
+class Lexer {
+    source;
+    tokens = [];
+    cursor = 0;
+    line = 1;
+    column = 1;
+    constructor(source) {
+        this.source = source;
+    }
+    tokenize() {
+        while (!this.isEnd()) {
+            const startLine = this.line;
+            const startColumn = this.column;
+            const char = this.peek();
+            if (char === " " || char === "\t" || char === "\r") {
+                this.advance();
+                continue;
+            }
+            if (char === "\n") {
+                this.advance();
+                this.add(tokens_1.TokenType.NEWLINE, "\\n", startLine, startColumn);
+                continue;
+            }
+            if (char === "/" && this.peek(1) === "/") {
+                while (!this.isEnd() && this.peek() !== "\n") {
+                    this.advance();
+                }
+                continue;
+            }
+            if (char === "/" && this.peek(1) === "*") {
+                this.advance();
+                this.advance();
+                while (!this.isEnd() &&
+                    !(this.peek() === "*" && this.peek(1) === "/")) {
+                    this.advance();
+                }
+                this.advance();
+                this.advance();
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                this.readString(char);
+                continue;
+            }
+            if (this.isDigit(char)) {
+                this.readNumber();
+                continue;
+            }
+            if (this.isIdentifierStart(char)) {
+                this.readIdentifier();
+                continue;
+            }
+            switch (char) {
+                case "(":
+                    this.simple(tokens_1.TokenType.LPAREN);
+                    break;
+                case ")":
+                    this.simple(tokens_1.TokenType.RPAREN);
+                    break;
+                case "{":
+                    this.simple(tokens_1.TokenType.LBRACE);
+                    break;
+                case "}":
+                    this.simple(tokens_1.TokenType.RBRACE);
+                    break;
+                case "[":
+                    this.simple(tokens_1.TokenType.LBRACT);
+                    break;
+                case "]":
+                    this.simple(tokens_1.TokenType.RBRACT);
+                    break;
+                case "+":
+                    if (this.match("+"))
+                        this.simple(tokens_1.TokenType.PLUSPLUS, "++");
+                    else
+                        this.simple(tokens_1.TokenType.PLUS);
+                    break;
+                case "-":
+                    if (this.match("-"))
+                        this.simple(tokens_1.TokenType.MINUSMINUS, "--");
+                    else
+                        this.simple(tokens_1.TokenType.MINUS);
+                    break;
+                case "*":
+                    if (this.match("*"))
+                        this.simple(tokens_1.TokenType.POWER, "**");
+                    else
+                        this.simple(tokens_1.TokenType.STAR);
+                    break;
+                case "/":
+                    this.simple(tokens_1.TokenType.SLASH);
+                    break;
+                case "%":
+                    this.simple(tokens_1.TokenType.PERCENT);
+                    break;
+                case "=":
+                    if (this.match("="))
+                        this.simple(tokens_1.TokenType.EQEQ, "==");
+                    else
+                        this.simple(tokens_1.TokenType.EQUAL);
+                    break;
+                case ":":
+                    if (this.match("="))
+                        this.simple(tokens_1.TokenType.COLONEQUAL, ":=");
+                    else
+                        this.simple(tokens_1.TokenType.COLON);
+                    break;
+                case "!":
+                    if (this.match("="))
+                        this.simple(tokens_1.TokenType.NOTEQ, "!=");
+                    else
+                        this.simple(tokens_1.TokenType.NOT);
+                    break;
+                case "<":
+                    if (this.match("="))
+                        this.simple(tokens_1.TokenType.LTEQ, "<=");
+                    else
+                        this.simple(tokens_1.TokenType.LT);
+                    break;
+                case ">":
+                    if (this.match("="))
+                        this.simple(tokens_1.TokenType.GTEQ, ">=");
+                    else
+                        this.simple(tokens_1.TokenType.GT);
+                    break;
+                case "&":
+                    if (this.match("&"))
+                        this.simple(tokens_1.TokenType.AND, "&&");
+                    else
+                        this.error("twa93na &&", "DCE12");
+                    break;
+                case "|":
+                    if (this.match("|"))
+                        this.simple(tokens_1.TokenType.OR, "||");
+                    else
+                        this.error("twa93na ||", "DCE12");
+                    break;
+                case ".":
+                    this.simple(tokens_1.TokenType.DOT);
+                    break;
+                case ",":
+                    this.simple(tokens_1.TokenType.COMMA);
+                    break;
+                case "?":
+                    this.simple(tokens_1.TokenType.QUESTION);
+                    break;
+                case ";":
+                    this.simple(tokens_1.TokenType.EOS);
+                    break;
+                default:
+                    this.error(`7arf mam3rofch '${char}'`, "DCE1");
+            }
+        }
+        this.tokens.push({
+            type: tokens_1.TokenType.EOF,
+            value: "",
+            line: this.line,
+            column: this.column,
+        });
+        return this.tokens;
+    }
+    readIdentifier() {
+        const line = this.line;
+        const column = this.column;
+        let value = "";
+        while (this.isIdentifierPart(this.peek())) {
+            value += this.advance();
+        }
+        const type = keywords[value] ?? tokens_1.TokenType.IDENTF;
+        this.add(type, value, line, column);
+    }
+    readNumber() {
+        const line = this.line;
+        const column = this.column;
+        let value = "";
+        while (this.isDigit(this.peek()) || this.peek() === "_") {
+            value += this.advance();
+        }
+        if (this.peek() === "." && this.isDigit(this.peek(1))) {
+            value += this.advance();
+            while (this.isDigit(this.peek())) {
+                value += this.advance();
+            }
+        }
+        this.add(tokens_1.TokenType.NUMBER, value.replaceAll("_", ""), line, column);
+    }
+    readString(quote) {
+        const start = {
+            line: this.line,
+            column: this.column
+        };
+        this.advance();
+        let value = "";
+        while (!this.isEnd() && this.peek() !== quote) {
+            const char = this.advance();
+            if (char === "\\") {
+                const next = this.advance();
+                switch (next) {
+                    case "n":
+                        value += "\n";
+                        break;
+                    case "t":
+                        value += "\t";
+                        break;
+                    default:
+                        value += next;
+                }
+            }
+            else {
+                value += char;
+            }
+        }
+        if (this.isEnd()) {
+            this.error("nass mamkmolch", "DCE11", "bhal haka -> \"wafin, al3alam !\"", start);
+        }
+        this.advance();
+        this.add(tokens_1.TokenType.STRING, value, start.line, start.column);
+    }
+    simple(type, value) {
+        const line = this.line;
+        const column = this.column;
+        const char = this.advance();
+        this.add(type, value ?? char, line, column);
+    }
+    match(expected) {
+        if (this.peek(1) !== expected)
+            return false;
+        this.advance();
+        return true;
+    }
+    add(type, value, line, column) {
+        this.tokens.push({
+            type,
+            value,
+            line,
+            column,
+        });
+    }
+    advance() {
+        const char = this.source[this.cursor++];
+        if (char === "\n") {
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        return char;
+    }
+    peek(offset = 0) {
+        return this.source[this.cursor + offset] ?? "\0";
+    }
+    isEnd() {
+        return this.cursor >= this.source.length;
+    }
+    isDigit(c) {
+        return c >= "0" && c <= "9";
+    }
+    isIdentifierStart(c) {
+        return /[a-zA-Z_]/.test(c);
+    }
+    isIdentifierPart(c) {
+        return /[a-zA-Z0-9_]/.test(c);
+    }
+    error(message, ecode, hint, location = {
+        line: this.line,
+        column: this.column
+    }) {
+        throw new errors_1.DarijaError({
+            code: ecode,
+            stage: "lexer",
+            message,
+            location,
+            hint: hint ?? ""
+        });
+    }
+}
+exports.Lexer = Lexer;