oclang 1.2.2 → 1.3.2

package/dist/core/runner/funcs/variables.js

@@ -0,0 +1,42 @@
+import { AlreadyDeclaredVariableError, CantModifyConstError, } from "../../../shared/manager/errors/semantic/undefined/declared.js";
+import { UndeclaredVariableError } from "../../../shared/manager/errors/semantic/undefined/undeclared.js";
+import { ValueType } from "../../../shared/models/value.js";
+import { solveString } from "../utils/string.js";
+export const variableStatement = (statement, context) => {
+    const varId = statement.id;
+    /*if (statement.set) {
+        if (!context.variables[varId]) {
+            new UndeclaredVariableError(varId).throw(
+                statement.sourceInfo.startLine,
+            );
+        }
+        if (context.variables[varId]?.props.isConst) {
+            new CantModifyConstError(varId).throw(
+                statement.sourceInfo.startLine,
+            );
+        }
+    } else if (!statement.var.props.isConst) {
+        if (context.variables[varId]) {
+            new AlreadyDeclaredVariableError(varId).throw(
+                statement.sourceInfo.startLine,
+            );
+        }
+    }*/
+    let value = statement.var.value;
+    switch (statement.var.type) {
+        case ValueType.String:
+            value = solveString(value, context, (err) => {
+                err.throw(statement.sourceInfo.startLine);
+            });
+            break;
+        default:
+            break;
+    }
+    context.variables[varId] = {
+        type: statement.var.type,
+        value,
+        props: {
+            isConst: !!statement.var.props.isConst,
+        },
+    };
+};

package/dist/core/runner/runner.js

@@ -1,108 +1,23 @@
-import { AlreadyDeclaredFunctionError, AlreadyDeclaredVariableError, CantModifyConstError, } from "../../shared/manager/errors/semantic/undefined/declared.js";
+import { AlreadyDeclaredFunctionError } from "../../shared/manager/errors/semantic/undefined/declared.js";
 import { UndeclaredFunctionError, UndeclaredVariableError, } from "../../shared/manager/errors/semantic/undefined/undeclared.js";
-import { createCoreContext } from "../context/coreContext.js";
-import { ValueType } from "../../shared/models/value.js";
-import { solveString } from "./utils/string.js";
 import { StatementKind } from "../ast/types/base/statement.js";
-import * as ctx from "../../shared/context/globalContext.js";
+// import { coreContext as context } from "../context/coreContext.js";
+import { printStatement } from "./funcs/io.js";
+import { variableStatement } from "./funcs/variables.js";
+import { callStatement, functionStatement } from "./funcs/functions.js";
+const statementMap = new Map([
+    [StatementKind.PrintStatement, printStatement],
+    [StatementKind.VariableStatement, variableStatement],
+    [StatementKind.FunctionStatement, functionStatement],
+    [StatementKind.CallStatement, callStatement],
+]);
 export function run(ast, context) {
     for (const statement of ast) {
-        switch (statement.kind) {
-            case StatementKind.PrintStatement:
-                printStatement(statement, context);
-                break;
-            case StatementKind.VariableStatement:
-                variableStatement(statement, context);
-                break;
-            case StatementKind.FunctionStatement:
-                functionStatement(statement, context);
-                break;
-            case StatementKind.CallStatement:
-                callStatement(statement, context);
-                break;
+        const runner = statementMap.get(statement.kind);
+        if (!runner) {
+            throw new Error(`No runner for statement kind: ${statement.kind}`);
         }
+        runner(statement, context);
     }
-}
-function printStatement(statement, context) {
-    let val;
-    switch (statement.value.type) {
-        case ValueType.Identifier:
-            const id = statement.value.value;
-            const varData = context.variables[id];
-            if (varData !== undefined) {
-                val = varData.value;
-            }
-            else {
-                new UndeclaredVariableError(id).throw(statement.sourceInfo.startLine);
-            }
-            break;
-        case ValueType.String:
-            val = solveString(statement.value.value, context, (err) => {
-                err.throw(statement.sourceInfo.startLine);
-            });
-            break;
-        default:
-            val = statement.value.value;
-            break;
-    }
-    const info = ctx.get("services").log;
-    info.info(val);
-}
-function variableStatement(statement, context) {
-    const varId = statement.id;
-    if (statement.set) {
-        if (!context.variables[varId]) {
-            new UndeclaredVariableError(varId).throw(statement.sourceInfo.startLine);
-        }
-        if (context.variables[varId]?.props.isConst) {
-            new CantModifyConstError(varId).throw(statement.sourceInfo.startLine);
-        }
-    }
-    else if (!statement.var.props.isConst) {
-        if (context.variables[varId]) {
-            new AlreadyDeclaredVariableError(varId).throw(statement.sourceInfo.startLine);
-        }
-    }
-    let value = statement.var.value;
-    switch (statement.var.type) {
-        case ValueType.String:
-            value = solveString(value, context, (err) => {
-                err.throw(statement.sourceInfo.startLine);
-            });
-            break;
-        default:
-            break;
-    }
-    context.variables[varId] = {
-        type: statement.var.type,
-        value,
-        props: {
-            isConst: !!statement.var.props.isConst,
-        },
-    };
-}
-function functionStatement(statement, context) {
-    const idToken = statement.id;
-    if (!idToken)
-        return;
-    const funcData = context.functions[idToken];
-    if (funcData) {
-        new AlreadyDeclaredFunctionError(idToken).throw(statement.sourceInfo.startLine);
-    }
-    const body = statement.func.body ?? [];
-    const scope = statement.func.scope;
-    context.functions[idToken] = {
-        body,
-        scope,
-    };
-}
-function callStatement(statement, context) {
-    const funcId = statement.id;
-    if (!funcId)
-        return;
-    const funcData = context.functions[funcId];
-    if (!funcData) {
-        new UndeclaredFunctionError(funcId).throw(statement.sourceInfo.startLine);
-    }
-    run(funcData.body, context.functions[funcId].scope);
+    return context;
 }

package/dist/core/services/log.service.js

@@ -11,16 +11,14 @@ export class LoggerService {
     constructor(config) {
         this.config = config;
     }
-    log(message, level = LogLevel.Info) {
+    log(message, level = LogLevel.Info, printMsg = message) {
         this.logs.push({ message, level });
-        this.config.interceptors.forEach(interceptor => {
+        this.config.interceptors.forEach((interceptor) => {
             if (interceptor.level === level) {
                 message = interceptor.onLog(message);
             }
         });
-        if (this.config.logs.includes(level)) {
-            console.log(message);
-        }
+        console.log(printMsg);
     }
     debug(message) {
         this.log(message, LogLevel.Debug);
@@ -41,10 +39,12 @@ export class LoggerService {
         this.config.interceptors.push(interceptor);
     }
     removeInterceptor(interceptor) {
-        this.config.interceptors = this.config.interceptors.filter(i => i !== interceptor);
+        this.config.interceptors = this.config.interceptors.filter((i) => i !== interceptor);
     }
     toString() {
-        return this.logs.map(log => `[${log.level}] ${log.message}`).join("\n");
+        return this.logs
+            .map((log) => `[${log.level}] ${log.message}`)
+            .join("\n");
     }
 }
 export const defaultLoggerConfig = {

package/dist/shared/context/globalContext.js

@@ -1,4 +1,10 @@
-let globalContext = {};
+let globalContext = { services: new Map() };
+export function pushService(service, name) {
+    globalContext.services.set(name, service);
+}
+export function getService(name) {
+    return globalContext.services.get(name);
+}
 export function get(key) {
     return globalContext[key];
 }

package/dist/shared/manager/baseManager.js

@@ -5,11 +5,13 @@ export class OcatManager {
     message;
     color;
     level;
+    printFn;
     constructor(name, color, level) {
         this.name = name;
         this.message = "";
         this.color = color;
         this.level = level;
+        this.printFn = console.log;
     }
     toString(line = undefined) {
         return `${this.color.bold(this.name)}${line ? chalk.gray(` at line ${line}`) : ""}: ${this.color.italic(this.message)}`;
@@ -22,9 +24,9 @@ export class OcatManager {
         return this;
     }
     throw(line = undefined) {
-        console.log(this.toString(line));
-        const log = ctx.get("services").log;
-        log.log(this.build(line), this.level);
+        const log = ctx.get("services")?.log;
+        const message = this.build(line);
+        log?.log(message, this.level, this.toString(line));
         process.exit(1);
     }
 }

package/dist/shared/manager/warn/coreWarnings.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
-import { OcatManager } from "../baseManager";
-import { LogLevel } from "../../../core/services/log.service";
+import { OcatManager } from "../baseManager.js";
+import { LogLevel } from "../../../core/services/log.service.js";
 export class OcatWarning extends OcatManager {
     constructor(name) {
         super(name, chalk.yellow, LogLevel.Warning);

package/package.json

@@ -1,30 +1,30 @@
-{
-  "name": "oclang",
-  "version": "1.2.2",
-  "description": "A programming language",
-  "author": "LuisRG-L, Orange Cat",
-  "license": "MIT",
-  "type": "module",
-  "module": "src/index.ts",
-  "bin": {
-    "ocat": "dist/cli/ocat/index.js",
-    "ocm": "dist/cli/ocm/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsc && npm link --force"
-  },
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "@types/node": "^25.0.3",
-    "chalk": "^5.6.2",
-    "chevrotain": "^11.0.3",
-    "commander": "^14.0.2",
-    "inquirer": "^13.1.0"
-  }
-}
+{
+  "name": "oclang",
+  "version": "1.3.2",
+  "description": "A programming language",
+  "author": "LuisRG-L, Orange Cat",
+  "license": "MIT",
+  "type": "module",
+  "module": "src/index.ts",
+  "bin": {
+    "ocat": "dist/cli/ocat/index.js",
+    "ocm": "dist/cli/ocm/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "rm -rf dist && tsc && npm link --force"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@types/node": "^25.0.3",
+    "chalk": "^5.6.2",
+    "chevrotain": "^11.0.3",
+    "commander": "^14.0.2",
+    "inquirer": "^13.1.0"
+  }
+}

package/src/cli/ocm/commands/run.ts

@@ -10,11 +10,6 @@ export function run() {
 	context.set("isProject", true);
 	context.set("projectConfig", projectConfig);
 	context.set("services", {});
-	context.useObject("services", services => {
-		return {
-			log: new LoggerService(defaultLoggerConfig),
-		};
-	});
 
 	runfile(projectConfig.main, { force: false });
 }

package/src/core/ast/astBuilder.ts

@@ -1,166 +1,35 @@
-import { createCoreContext, type CoreContext } from "../context/coreContext.js";
-import { ValueType } from "../../shared/models/value.js";
-import { StatementKind } from "./types/base/index.js";
 import type { AnyStatement, PrintStatement } from "./types/statements/index.js";
+import { ioStatements } from "./statements/io.js";
+import { variableStatements } from "./statements/vars.js";
+import { functionStatements } from "./statements/function.js";
+import { importStatements } from "./statements/import.js";
+import type { FBuilder } from "./statements/_base.js";
 
 export type BuildType = AnyStatement | null;
 
+const possibleStatements: FBuilder<AnyStatement>[] = [
+	...ioStatements,
+	...variableStatements,
+	...functionStatements,
+	...importStatements,
+];
+
 export function buildAst(cst: any): AnyStatement[] {
 	const statements = cst.children.statement ?? [];
 	const ast: AnyStatement[] = [];
 
-	for (const statement of statements) {
-		let __tmp: BuildType = null;
-		const __$tmp = () => { if (__tmp) ast.push(__tmp); }
-		__tmp = printStatement(statement);
-		__$tmp();
-		__tmp = variableStatement(statement);
-		__$tmp();
-		__tmp = functionStatement(statement);
-		__$tmp();
-		__tmp = callStatement(statement);
-		__$tmp();
-	}
-
-	return ast;
-}
-
-export type FBuilder = (statement: any) => AnyStatement | null;
+	for (const node of statements) {
+		let built: AnyStatement | null = null;
 
-const printStatement: FBuilder = (statement: any) => {
-	const printStmt = statement.children.printStatement?.[0];
-	if (printStmt) {
-		const strToken = printStmt.children.StringLiteral?.[0];
-		if (strToken) {
-			return {
-				kind: StatementKind.PrintStatement,
-				sourceInfo: {
-					tokens: printStmt.children,
-					cstNode: printStmt,
-					startLine: printStmt.startLine,
-					endLine: printStmt.endLine,
-					startColumn: printStmt.startColumn,
-					endColumn: printStmt.endColumn,
-				},
-				value: {
-					value: strToken.image,
-					type: ValueType.String,
-				}
-			} as PrintStatement;
+		for (const builder of possibleStatements) {
+			built = builder(node);
+			if (built) break;
 		}
 
-		const idToken = printStmt.children.Identifier?.[0];
-		if (idToken) {
-			return {
-				kind: StatementKind.PrintStatement,
-				sourceInfo: {
-					tokens: printStmt.children,
-					cstNode: printStmt,
-					startLine: printStmt.startLine,
-					endLine: printStmt.endLine,
-					startColumn: printStmt.startColumn,
-					endColumn: printStmt.endColumn,
-				},
-				value: {
-					value: idToken.image,
-					type: ValueType.Identifier,
-				}
-			}
+		if (built) {
+			ast.push(built);
 		}
 	}
-	return null;
-}
 
-const variableStatement: FBuilder = (statement: any) => {
-	const varStmt = statement.children.variableStatement?.[0];
-	if (varStmt) {
-		const typeToken = varStmt.children.VarType?.[0];
-		const idToken = varStmt.children.Identifier?.[0];
-		const valueToken =
-			varStmt.children.StringLiteral?.[0] ??
-			varStmt.children.NumberLiteral?.[0] ??
-			varStmt.children.BooleanLiteral?.[0];
-
-		if (!typeToken || !idToken || !valueToken) return null;
-
-		const setToken = varStmt.children.Set?.[0];
-		const constToken = varStmt.children.Const?.[0];
-
-		const type = typeToken.image as ValueType;
-		const id = idToken.image;
-		const value: string = valueToken.image;
-		return {
-			kind: StatementKind.VariableStatement,
-			sourceInfo: {
-				tokens: varStmt.children,
-				cstNode: varStmt,
-				startLine: varStmt.startLine,
-				endLine: varStmt.endLine,
-				startColumn: varStmt.startColumn,
-				endColumn: varStmt.endColumn,
-			},
-			id,
-			var: {
-				type,
-				value,
-				props: {
-					isConst: !!constToken,
-				}
-			},
-			set: !!setToken,
-		}
-	}
-	return null;
-}
-
-const functionStatement: FBuilder = (statement: any) => {
-	const funcStmt = statement.children.functionStatement?.[0];
-	if (funcStmt) {
-		const idToken = funcStmt.children.Identifier?.[0];
-		if (!idToken) return null;
-		const id = idToken.image;
-
-		const body = buildAst(funcStmt) ;
-
-		return {
-			kind: StatementKind.FunctionStatement,
-			sourceInfo: {
-				tokens: funcStmt.children,
-				cstNode: funcStmt,
-				startLine: funcStmt.startLine,
-				endLine: funcStmt.endLine,
-				startColumn: funcStmt.startColumn,
-				endColumn: funcStmt.endColumn,
-			},
-			id,
-			func: {
-				body,
-				scope: createCoreContext(),
-			}
-		}
-	}
-	return null
-}
-
-const callStatement: FBuilder = (statement: any) => {
-	const callStmt = statement.children.callStatement?.[0];
-	if (callStmt) {
-		const idToken = callStmt.children.Identifier?.[0];
-		if (!idToken) return null;
-		const id = idToken.image;
-
-		return {
-			kind: StatementKind.CallStatement,
-			sourceInfo: {
-				tokens: callStmt.children,
-				cstNode: callStmt,
-				startLine: callStmt.startLine,
-				endLine: callStmt.endLine,
-				startColumn: callStmt.startColumn,
-				endColumn: callStmt.endColumn,
-			},
-			id,
-		};
-	}
-	return null;
-};
+	return ast;
+}

package/src/core/ast/statements/_base.ts

@@ -0,0 +1,3 @@
+import type { AnyStatement } from "../types/statements/index.js";
+
+export type FBuilder<T> = (statement: any) => T | null;

package/src/core/ast/statements/function.ts

@@ -0,0 +1,60 @@
+import { createCoreContext } from "../../context/coreContext.js";
+import { buildAst } from "../astBuilder.js";
+import { StatementKind } from "../types/base/index.js";
+import type { CallStatement } from "../types/statements/callStatement.js";
+import type { FunctionStatement } from "../types/statements/functionStatement.js";
+import type { FBuilder } from "./_base.js";
+
+const functionStatement: FBuilder<FunctionStatement> = (statement: any) => {
+	const funcStmt = statement.children.functionStatement?.[0];
+	if (funcStmt) {
+		const idToken = funcStmt.children.Identifier?.[0];
+		if (!idToken) return null;
+		const id = idToken.image;
+
+		const body = buildAst(funcStmt);
+
+		return {
+			kind: StatementKind.FunctionStatement,
+			sourceInfo: {
+				tokens: funcStmt.children,
+				cstNode: funcStmt,
+				startLine: funcStmt.startLine,
+				endLine: funcStmt.endLine,
+				startColumn: funcStmt.startColumn,
+				endColumn: funcStmt.endColumn,
+			},
+			id,
+			func: {
+				body,
+				scope: createCoreContext(),
+			},
+		};
+	}
+	return null;
+};
+
+const callStatement: FBuilder<CallStatement> = (statement: any) => {
+	const callStmt = statement.children.callStatement?.[0];
+	if (callStmt) {
+		const idToken = callStmt.children.Identifier?.[0];
+		if (!idToken) return null;
+		const id = idToken.image;
+
+		return {
+			kind: StatementKind.CallStatement,
+			sourceInfo: {
+				tokens: callStmt.children,
+				cstNode: callStmt,
+				startLine: callStmt.startLine,
+				endLine: callStmt.endLine,
+				startColumn: callStmt.startColumn,
+				endColumn: callStmt.endColumn,
+			},
+			id,
+		};
+	}
+	return null;
+};
+
+export const functionStatements = [functionStatement, callStatement];

package/src/core/ast/statements/import.ts

@@ -0,0 +1,22 @@
+import { StatementKind } from "../types/base/index.js";
+import type { ImportStatement } from "../types/statements/importStatement.js";
+import type { FBuilder } from "./_base.js";
+
+const importStatement: FBuilder<ImportStatement> = (statement: any) => {
+	const node = statement.children.importStatement?.[0];
+	if (!node) return null;
+
+	const stringToken = node.children.StringLiteral?.[0];
+	if (!stringToken) return null;
+
+	const rawValue = stringToken.image;
+
+	const path = rawValue.slice(1, -1) as string;
+
+	return {
+		kind: StatementKind.ImportStatement,
+		path,
+	};
+};
+
+export const importStatements = [importStatement];

package/src/core/ast/statements/io.ts

@@ -0,0 +1,50 @@
+import { ValueType } from "../../../shared/models/value.js";
+import { StatementKind } from "../types/base/index.js";
+import type { PrintStatement } from "../types/statements/index.js";
+import type { FBuilder } from "./_base.js";
+
+const printStatement: FBuilder<PrintStatement> = (statement: any) => {
+	const printStmt = statement.children.printStatement?.[0];
+	if (printStmt) {
+		const strToken = printStmt.children.StringLiteral?.[0];
+		if (strToken) {
+			return {
+				kind: StatementKind.PrintStatement,
+				sourceInfo: {
+					tokens: printStmt.children,
+					cstNode: printStmt,
+					startLine: printStmt.startLine,
+					endLine: printStmt.endLine,
+					startColumn: printStmt.startColumn,
+					endColumn: printStmt.endColumn,
+				},
+				value: {
+					value: strToken.image,
+					type: ValueType.String,
+				},
+			};
+		}
+
+		const idToken = printStmt.children.Identifier?.[0];
+		if (idToken) {
+			return {
+				kind: StatementKind.PrintStatement,
+				sourceInfo: {
+					tokens: printStmt.children,
+					cstNode: printStmt,
+					startLine: printStmt.startLine,
+					endLine: printStmt.endLine,
+					startColumn: printStmt.startColumn,
+					endColumn: printStmt.endColumn,
+				},
+				value: {
+					value: idToken.image,
+					type: ValueType.Identifier,
+				},
+			};
+		}
+	}
+	return null;
+};
+
+export const ioStatements = [printStatement];