darijacode 0.2.0

package/dist/compiler/checker/statements.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatementChecker = void 0;
+const errors_1 = require("../errors");
+const showType_1 = require("../../utils/showType");
+const types_1 = require("./types");
+const expressions_1 = require("./expressions");
+class StatementChecker {
+    functions;
+    globalScope;
+    typeChecker;
+    expressionChecker;
+    loopDepth = 0;
+    functionStack = [];
+    constructor(functions, globalScope) {
+        this.functions = functions;
+        this.globalScope = globalScope;
+        this.typeChecker = new types_1.TypeChecker();
+        this.expressionChecker = new expressions_1.ExpressionChecker(functions);
+    }
+    /**
+     * Check a statement and validate it semantically.
+     */
+    checkStatement(stmt, scope) {
+        switch (stmt.type) {
+            case "VariableDeclaration":
+                return this.checkVariableDeclaration(stmt, scope);
+            case "FunctionDeclaration":
+                return this.checkFunctionDeclaration(stmt);
+            case "ReturnStatement":
+                return this.checkReturnStatement(stmt, scope);
+            case "IfStatement":
+                return this.checkIfStatement(stmt, scope);
+            case "WhileStatement":
+                return this.checkWhileStatement(stmt, scope);
+            case "ForStatement":
+                return this.checkForStatement(stmt, scope);
+            case "BreakStatement":
+                return this.checkBreakStatement(stmt);
+            case "ContinueStatement":
+                return this.checkContinueStatement(stmt);
+            case "BlockStatement":
+                return this.checkBlock(stmt, scope);
+            case "PrintStatement":
+                return this.checkPrintStatement(stmt, scope);
+            case "ExpressionStatement":
+                return this.checkExpressionStatement(stmt, scope);
+            default:
+                throw new errors_1.DarijaError({
+                    code: "DCE1",
+                    stage: "checker",
+                    message: `'${stmt.type}' mmd3omach`,
+                    location: {
+                        line: stmt.pos.line,
+                        column: stmt.pos.column,
+                    },
+                });
+        }
+    }
+    checkVariableDeclaration(decl, scope) {
+        let type = decl.typeAnnotation
+            ? this.typeChecker.resolveType(decl.typeAnnotation, decl.pos.line, decl.pos.column)
+            : { base: "unknown", d: 0 };
+        if (decl.init) {
+            const initType = this.expressionChecker.inferType(decl.init, scope);
+            if (decl.typeAnnotation &&
+                !this.typeChecker.compatible(decl.typeAnnotation, initType)) {
+                throw new errors_1.DarijaError({
+                    code: "DCE15",
+                    stage: "checker",
+                    message: `twa93na ${(0, showType_1.showType)(decl.typeAnnotation)}, wlkin l9ina ${(0, showType_1.showType)(initType)}`,
+                    location: {
+                        line: decl.pos.line,
+                        column: decl.pos.column,
+                    },
+                    hint: `ach ban link tstkhdm ${(0, showType_1.showType)(decl.typeAnnotation)} fbalst ${(0, showType_1.showType)(initType)}`,
+                });
+            }
+            if (decl.typeAnnotation) {
+                type = initType;
+            }
+        }
+        else if (decl.kind === "khli") {
+            throw new errors_1.DarijaError({
+                code: "DCE16",
+                stage: "checker",
+                message: `'${decl.name}' howa tabit idan khaso 9ima flwl`,
+                location: {
+                    line: decl.pos.line,
+                    column: decl.pos.column,
+                },
+            });
+        }
+        scope.declare(decl.name, { kind: decl.kind, type }, decl.pos.line, decl.pos.column);
+    }
+    checkFunctionDeclaration(fn) {
+        if (!this.functions.has(fn.name)) {
+            this.registerFunction(fn);
+        }
+        const info = this.functions.get(fn.name);
+        const fnScope = this.globalScope.child();
+        // Declare parameters in function scope
+        for (const param of fn.params) {
+            if (param.defaultValue && param.typeAnnotation) {
+                const defaultType = this.expressionChecker.inferType(param.defaultValue, fnScope);
+                if (!this.typeChecker.compatible(param.typeAnnotation, defaultType)) {
+                    throw new errors_1.DarijaError({
+                        code: "DCE15",
+                        stage: "checker",
+                        message: `twa93na ${(0, showType_1.showType)(param.typeAnnotation)}, wlkin l9ina ${(0, showType_1.showType)(defaultType)}`,
+                        location: {
+                            line: param.pos.line,
+                            column: param.pos.column,
+                        },
+                        hint: `ach ban link tstkhdm ${(0, showType_1.showType)(param.typeAnnotation)} fbalst ${(0, showType_1.showType)(defaultType)}`,
+                    });
+                }
+            }
+            fnScope.declare(param.name, {
+                kind: "param",
+                type: param.typeAnnotation ?? { base: types_1.UNKNOWN, d: 0 },
+            }, param.pos.line, param.pos.column);
+        }
+        this.functionStack.push(info);
+        this.checkBlock(fn.body, fnScope);
+        this.functionStack.pop();
+    }
+    registerFunction(fn) {
+        if (this.functions.has(fn.name)) {
+            throw new errors_1.DarijaError({
+                code: "DCE13",
+                stage: "checker",
+                message: `dala '${fn.name}' dija m3rfa`,
+                location: {
+                    line: fn.pos.line,
+                    column: fn.pos.column,
+                },
+                hint: `stkhdm dalla dyal ${fn.name}() awla dir dalla jdida`,
+            });
+        }
+        this.functions.register(fn.name, {
+            params: fn.params,
+            returnType: fn.returnType ?? { base: "khawi", d: 0 },
+        }, fn.pos.line, fn.pos.column);
+    }
+    checkReturnStatement(stmt, scope) {
+        const fn = this.functionStack[this.functionStack.length - 1];
+        if (!fn) {
+            throw new errors_1.DarijaError({
+                code: "DCE14",
+                stage: "checker",
+                message: "'raj3' mst5dma bra dyal ddalla",
+                location: {
+                    line: stmt.pos.line,
+                    column: stmt.pos.column,
+                },
+                hint: "dirha lldakhl dyal dalla",
+            });
+        }
+        if (stmt.argument) {
+            const argType = this.expressionChecker.inferType(stmt.argument, scope);
+            const tp = { base: fn.returnType.base, d: fn.returnType.d };
+            if (fn.returnType && !this.typeChecker.compatible(tp, argType)) {
+                throw new errors_1.DarijaError({
+                    code: "DCE15",
+                    stage: "checker",
+                    message: `mknach kanstaw l9ima dyal '${(0, showType_1.showType)(argType)}', kona mtw93in '${(0, showType_1.showType)(fn.returnType)}'`,
+                    location: {
+                        line: stmt.pos.line,
+                        column: stmt.pos.column,
+                    },
+                    hint: `ach ban lik traj3 ${(0, showType_1.showType)(fn.returnType)} fbalst ${(0, showType_1.showType)(argType)} ?`,
+                });
+            }
+        }
+    }
+    checkIfStatement(stmt, scope) {
+        this.expressionChecker.inferType(stmt.condition, scope);
+        this.checkBlock(stmt.consequent, scope);
+        for (const branch of stmt.elseIfs) {
+            this.expressionChecker.inferType(branch.condition, scope);
+            this.checkBlock(branch.consequent, scope);
+        }
+        if (stmt.alternate) {
+            this.checkBlock(stmt.alternate, scope);
+        }
+    }
+    checkWhileStatement(stmt, scope) {
+        this.expressionChecker.inferType(stmt.condition, scope);
+        this.loopDepth++;
+        this.checkBlock(stmt.body, scope);
+        this.loopDepth--;
+    }
+    checkForStatement(stmt, scope) {
+        const forScope = scope.child();
+        if (stmt.init) {
+            if (stmt.init.type === "VariableDeclaration") {
+                this.checkVariableDeclaration(stmt.init, forScope);
+            }
+            else {
+                this.expressionChecker.inferType(stmt.init.expression, forScope);
+            }
+        }
+        if (stmt.condition) {
+            this.expressionChecker.inferType(stmt.condition, forScope);
+        }
+        if (stmt.update) {
+            this.expressionChecker.inferType(stmt.update, forScope);
+        }
+        this.loopDepth++;
+        this.checkBlock(stmt.body, forScope);
+        this.loopDepth--;
+    }
+    checkBreakStatement(stmt) {
+        if (this.loopDepth === 0) {
+            throw new errors_1.DarijaError({
+                code: "DCE14",
+                stage: "checker",
+                message: "'qta3' mst5dma bra dyal dwara",
+                location: {
+                    line: stmt.pos.line,
+                    column: stmt.pos.column,
+                },
+                hint: "dir '9ta3' fldakhl dyal chi dwara",
+            });
+        }
+    }
+    checkContinueStatement(stmt) {
+        if (this.loopDepth === 0) {
+            throw new errors_1.DarijaError({
+                code: "DCE14",
+                stage: "checker",
+                message: "'kml' mst5dma bra by dwara",
+                location: {
+                    line: stmt.pos.line,
+                    column: stmt.pos.column,
+                },
+                hint: "dir 'kml' fldakhl dyal chi dwara",
+            });
+        }
+    }
+    checkBlock(block, parentScope) {
+        const scope = parentScope.child();
+        for (const stmt of block.body) {
+            this.checkStatement(stmt, scope);
+        }
+    }
+    checkPrintStatement(stmt, scope) {
+        this.expressionChecker.inferType(stmt.argument, scope);
+    }
+    checkExpressionStatement(stmt, scope) {
+        this.expressionChecker.inferType(stmt.expression, scope);
+    }
+}
+exports.StatementChecker = StatementChecker;

package/dist/compiler/checker/types.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeChecker = exports.UNKNOWN = void 0;
+const errors_1 = require("../errors");
+const showType_1 = require("../../utils/showType");
+exports.UNKNOWN = "unknown";
+class TypeChecker {
+    resolveType(type, line, column) {
+        if (!["ra9m", "nass", "tona2i", "khawi"].includes(type.base)) {
+            throw new errors_1.DarijaError({
+                code: "DCE18",
+                stage: "checker",
+                message: `had naw3 '${(0, showType_1.showType)(type)}' mkaynch awla mmd3omch`,
+                location: { line, column },
+                hint: "stkhdm chi naw3 dija kayn bhal : 'ra9m', 'nass' etc..",
+            });
+        }
+        return { base: type.base, d: type.d };
+    }
+    /**
+     * Check if two types are compatible.
+     * Returns true if types match or either is UNKNOWN (dynamic).
+     */
+    compatible(declared, actual) {
+        if (declared.base === exports.UNKNOWN || actual.base === exports.UNKNOWN)
+            return true;
+        return (0, showType_1.showType)(declared) === (0, showType_1.showType)(actual);
+    }
+    isType(type, base, d = 0) {
+        return (0, showType_1.isType)(type, base, d);
+    }
+    /**
+     * Assert that actual type matches expected base type.
+     * Throws DCE15 on mismatch (unless actual is UNKNOWN).
+     */
+    expectType(actual, expected, pos) {
+        if (!this.isType(actual, expected) && actual.base !== exports.UNKNOWN) {
+            throw new errors_1.DarijaError({
+                code: "DCE15",
+                stage: "checker",
+                message: `twa93na ${expected}, wlkin l9ina ${(0, showType_1.showType)(actual)}`,
+                location: { line: pos.line, column: pos.column },
+            });
+        }
+    }
+}
+exports.TypeChecker = TypeChecker;

package/dist/compiler/codegen/codegen.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Codegen = void 0;
+const scope_1 = __importDefault(require("./scope"));
+const stmts_1 = __importDefault(require("./stmts"));
+const expr_1 = __importDefault(require("./expr"));
+const infertype_1 = __importDefault(require("./infertype"));
+const ctype_1 = require("./ctype");
+const runtime_1 = require("./runtime");
+const RUNTIME_PRELUDE = `
+static char* dj_concat(const char* a, const char* b) {
+    size_t len = strlen(a) + strlen(b) + 1;
+    char* out = (char*)malloc(len);
+    strcpy(out, a);
+    strcat(out, b);
+    return out;
+}
+`.trim();
+class Codegen {
+    globalScope = new scope_1.default();
+    functions = new Map();
+    out = [];
+    indentLevel = 0;
+    generate(program) {
+        const functionDecls = program.body.filter((s) => s.type === "FunctionDeclaration");
+        const topLevel = program.body.filter((s) => s.type !== "FunctionDeclaration");
+        for (const fn of functionDecls)
+            this.registerFunction(fn);
+        const header = [
+            "#include <stdio.h>",
+            "#include <stdlib.h>",
+            "#include <string.h>",
+            "#include <stdbool.h>",
+            "#include <math.h>",
+            "",
+            RUNTIME_PRELUDE,
+            "",
+        ];
+        const prototypes = functionDecls.map((fn) => this.genPrototype(fn) + ";");
+        const bodies = [];
+        for (const fn of functionDecls) {
+            bodies.push(this.genFunction(fn));
+            bodies.push("");
+        }
+        const main = ["int main(void) {"];
+        this.indentLevel = 1;
+        this.out = [];
+        for (const stmt of topLevel)
+            this.genStatement(stmt, this.globalScope);
+        main.push(...this.out);
+        main.push("    return 0;", "}");
+        this.indentLevel = 0;
+        return [...header, ...prototypes, "", ...bodies, ...main].join("\n");
+    }
+    registerFunction(fn) {
+        // uses of as 
+        const paramTypes = fn.params.map((p) => p.typeAnnotation ?? { base: "nass", d: 0 });
+        this.functions.set(fn.name, {
+            paramTypes,
+            returnType: fn.returnType ?? { base: "khawi", d: 0 }
+        });
+    }
+    genPrototype(fn) {
+        const sig = this.functions.get(fn.name);
+        const params = fn.params
+            .map((p, i) => `${this.cType(sig.paramTypes[i])} ${p.name}`)
+            .join(", ");
+        return `${this.cType(sig.returnType)} ${fn.name}(${params || "void"})`;
+    }
+    genFunction(fn) {
+        const sig = this.functions.get(fn.name);
+        const fnScope = this.globalScope.child();
+        fn.params.forEach((p, i) => fnScope.declare(p.name, sig.paramTypes[i]));
+        this.out = [];
+        this.indentLevel = 1;
+        for (const stmt of fn.body.body)
+            this.genStatement(stmt, fnScope);
+        const body = this.out;
+        this.indentLevel = 0;
+        return [`${this.genPrototype(fn)} {`, ...body, "}"].join("\n");
+    }
+    genStatement(stmt, scope) {
+        return (0, stmts_1.default)(this, stmt, scope);
+    }
+    genNestedBlock(block, parentScope) {
+        this.indentLevel++;
+        const scope = parentScope.child();
+        for (const stmt of block.body)
+            this.genStatement(stmt, scope);
+        this.indentLevel--;
+    }
+    genPrint(expr, type, scope) {
+        const value = this.genExpression(expr, scope);
+        return (0, runtime_1.dj_print)(value, type, expr.pos.line, expr.pos.column);
+    }
+    genExpression(expr, scope) {
+        return (0, expr_1.default)(this, expr, scope);
+    }
+    // ---------------------------------------------
+    // Types
+    // ---------------------------------------------
+    inferType(expr, scope) {
+        return (0, infertype_1.default)(this, expr, scope);
+    }
+    cType(type) {
+        return (0, ctype_1.cType)(this, type);
+    }
+    emit(line) {
+        this.out.push("    ".repeat(this.indentLevel) + line);
+    }
+    escapeString(value) {
+        return value
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, "\\n")
+            .replace(/\t/g, "\\t");
+    }
+}
+exports.Codegen = Codegen;

package/dist/compiler/codegen/ctype.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cType = cType;
+function cType(codegen, type) {
+    let c;
+    switch (type.base) {
+        case "ra9m":
+            c = "double";
+            break;
+        case "nass":
+            c = "char*";
+            break;
+        case "tona2i":
+            c = "bool";
+            break;
+        case "khawi":
+            c = "void*";
+            break;
+        default:
+            c = "void*";
+    }
+    return type.d !== undefined && type.d > 0 ? (c + "*".repeat(type.d)) : c;
+}

package/dist/compiler/codegen/expr.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = genExpression;
+const errors_1 = require("../errors");
+const showType_1 = require("../../utils/showType");
+function genExpression(codegen, expr, scope) {
+    switch (expr.type) {
+        case "NumericLiteral":
+            return String(expr.value);
+        case "StringLiteral":
+            return `"${codegen.escapeString(expr.value)}"`;
+        case "BooleanLiteral":
+            return expr.value ? "true" : "false";
+        case "NullLiteral":
+            return "NULL";
+        case "Identifier":
+            return expr.name;
+        case "AssignmentExpression":
+            return `${codegen.genExpression(expr.target, scope)} = ${codegen.genExpression(expr.value, scope)}`;
+        case "BinaryExpression": {
+            const leftType = codegen.inferType(expr.left, scope);
+            const rightType = codegen.inferType(expr.right, scope);
+            const left = codegen.genExpression(expr.left, scope);
+            const right = codegen.genExpression(expr.right, scope);
+            if (expr.operator === "+" && ((0, showType_1.isType)(leftType, "nass")) || (0, showType_1.isType)(rightType, "nass")) {
+                return `dj_concat(${left}, ${right})`;
+            }
+            if (expr.operator === "**") {
+                return `pow(${left}, ${right})`;
+            }
+            return `(${left} ${expr.operator} ${right})`;
+        }
+        case "LogicalExpression": {
+            const op = expr.operator === "&&" ? "&&" : "||";
+            return `(${codegen.genExpression(expr.left, scope)} ${op} ${codegen.genExpression(expr.right, scope)})`;
+        }
+        case "UnaryExpression":
+            return `(${expr.operator}${codegen.genExpression(expr.argument, scope)})`;
+        case "UpdateExpression": {
+            const arg = codegen.genExpression(expr.argument, scope);
+            return expr.prefix ? `(${expr.operator}${arg})` : `(${arg}${expr.operator})`;
+        }
+        case "ConditionalExpression":
+            return `(${codegen.genExpression(expr.condition, scope)} ? ${codegen.genExpression(expr.consequent, scope)} : ${codegen.genExpression(expr.alternate, scope)})`;
+        case "CallExpression": {
+            if (expr.callee.type !== "Identifier") {
+                throw new errors_1.CodegenError("ghir dawal lli direct lli md3omin", expr.pos.line, expr.pos.column);
+            }
+            const args = expr.args.map((a) => codegen.genExpression(a, scope)).join(", ");
+            return `${expr.callee.name}(${args})`;
+        }
+        case "MemberExpression": {
+            if (!expr.computed) {
+                throw new errors_1.CodegenError("lwosol llmajal mmd3omch l7d sa3a", expr.pos.line, expr.pos.column);
+            }
+            return `${codegen.genExpression(expr.object, scope)}[${codegen.genExpression(expr.property, scope)}]`;
+        }
+        case "ArrayExpression":
+            throw new errors_1.CodegenError("l9yam dyal lmasfofat mmd3ominch bchakl kaaml l7d sa3a", expr.pos.line, expr.pos.column);
+        default:
+            throw new errors_1.CodegenError(`'${expr.type}' ba9i mmd3omach`, expr.pos.line, expr.pos.column);
+    }
+}

package/dist/compiler/codegen/infertype.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = inferType;
+const errors_1 = require("../errors");
+const showType_1 = require("../../utils/showType");
+function inferType(codegen, expr, scope) {
+    switch (expr.type) {
+        case "NumericLiteral":
+            return { base: "ra9m" };
+        case "StringLiteral":
+            return { base: "nass" };
+        case "BooleanLiteral":
+            return { base: "tona2i" };
+        case "NullLiteral":
+            return { base: "khawi" };
+        case "Identifier": {
+            const type = scope.resolve(expr.name);
+            if (!type) {
+                throw new errors_1.CodegenError(`'${expr.name}' mm3rofach`, expr.pos.line, expr.pos.column);
+            }
+            return type;
+        }
+        case "ArrayExpression": {
+            if (expr.elements.length === 0)
+                return { base: "unknown", d: 1 };
+            const t = codegen.inferType(expr.elements[0], scope);
+            return { base: t.base, d: t.d ? t.d + 1 : 0 };
+        }
+        case "AssignmentExpression":
+            return codegen.inferType(expr.value, scope);
+        case "BinaryExpression": {
+            if (["==", "!=", "<", "<=", ">", ">="].includes(expr.operator))
+                return { base: "tona2i" };
+            if (expr.operator === "+") {
+                const leftType = codegen.inferType(expr.left, scope);
+                const rightType = codegen.inferType(expr.right, scope);
+                if ((0, showType_1.isType)(leftType, "nass") || (0, showType_1.isType)(rightType, "nass")) {
+                    return { base: "nass", d: 0 };
+                }
+                return { base: "ra9m", d: 0 };
+            }
+            return { base: "ra9m" };
+        }
+        case "LogicalExpression":
+            return { base: "tona2i" };
+        case "UnaryExpression":
+            return expr.operator === "!" ? { base: "tona2i" } : { base: "ra9m" };
+        case "UpdateExpression":
+            return { base: "ra9m" };
+        case "ConditionalExpression": {
+            const consequentType = codegen.inferType(expr.consequent, scope);
+            const alternateType = codegen.inferType(expr.alternate, scope);
+            return consequentType === alternateType ? consequentType : { base: "unknown" };
+        }
+        case "CallExpression": {
+            if (expr.callee.type !== "Identifier")
+                return { base: "unknown" };
+            return codegen.functions.get(expr.callee.name)?.returnType ?? { base: "unknown", d: 0 };
+        }
+        case "MemberExpression": {
+            const objectType = codegen.inferType(expr.object, scope);
+            if (objectType.d && objectType.d > 0) {
+                return { base: objectType.base, d: objectType.d - 1 };
+            }
+            return { base: "unknown" };
+        }
+        default:
+            return { base: "unknown" };
+    }
+}

package/dist/compiler/codegen/runtime.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dj_print = dj_print;
+const errors_1 = require("../errors");
+function dj_print(value, type, line, column) {
+    if (type.d) {
+        if (type.d > 0)
+            throw new errors_1.CodegenError("tba3t lmasfofat mazal mamd3omch", line, column);
+    }
+    switch (type.base) {
+        case "nass":
+            return `printf("%s\\n", ${value});`;
+        case "ra9m":
+            return `printf("%g\\n", ${value});`;
+        case "tona2i":
+            return `printf("%s\\n", ${value} ? "sa7i7" : "ghalat");`;
+        case "khawi":
+            return `printf("khawi\\n");`;
+        case "unknown":
+            return `printf("mm3rofch\\n");`;
+        default:
+            throw new errors_1.CodegenError(`ma9drnach ntab3o had naw3 l7ad sa3a : ${type}`, line, column);
+    }
+}

package/dist/compiler/codegen/scope.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Scope {
+    parent;
+    vars = new Map();
+    constructor(parent = null) {
+        this.parent = parent;
+    }
+    declare(name, type) {
+        this.vars.set(name, type);
+    }
+    resolve(name) {
+        return this.vars.get(name) ?? this.parent?.resolve(name);
+    }
+    child() {
+        return new Scope(this);
+    }
+}
+exports.default = Scope;