oclang 1.2.3 → 1.3.2

package/src/core/index.ts

@@ -3,8 +3,9 @@ import { OcatParser } from "./parser/parser.js";
 import { run } from "./runner/runner.js";
 import { createCoreContext } from "./context/coreContext.js";
 import { buildAst } from "./ast/astBuilder.js";
-import * as ctx from "../shared/context/globalContext.js";
+import * as gctx from "../shared/context/globalContext.js";
 import fs from "fs";
+import { defaultLoggerConfig, LoggerService } from "./services/log.service.js";
 
 export function execute(code: string) {
 	const lexingResult = ocatLexer.tokenize(code);
@@ -15,12 +16,14 @@ export function execute(code: string) {
 	const ast = buildAst(cst);
 
 	process.on("exit", () => {
-		if (ctx.get("isProject")) {
-			const logs = ctx.get("services").log.toString();
+		if (gctx.get("isProject")) {
+			const logs = gctx.get("services").log.toString();
 			fs.writeFileSync(".ocat/logs.txt", logs);
 		}
 	});
 
-	const context = createCoreContext();
-	run(ast, context);
+	gctx.pushService(new LoggerService(defaultLoggerConfig), "log");
+	
+	const ctx = run(ast, createCoreContext());
+	return ctx;
 }

package/src/core/parser/parser.ts

@@ -4,9 +4,7 @@ import * as token from "../lexer/tokens/index.js";
 
 export class OcatParser extends CstParser {
 	constructor() {
-		super(token.allTokens, {
-			recoveryEnabled: true,
-		});
+		super(token.allTokens, { recoveryEnabled: true });
 		this.performSelfAnalysis();
 	}
 
@@ -50,12 +48,13 @@ export class OcatParser extends CstParser {
 	});
 
 	public importStatement = this.RULE("importStatement", () => {
-		this.CONSUME(token.Import);
-		this.CONSUME(token.StringLiteral);
+		const imp = this.CONSUME(token.Import);
+		const path = this.CONSUME(token.StringLiteral);
+		// opcional: guardar tokens para el AST
 	});
 
 	public printStatement = this.RULE("printStatement", () => {
-		this.CONSUME(token.Output);
+		const output = this.CONSUME(token.Output);
 		this.CONSUME(token.LeftParen);
 		this.OR([
 			...token.literals.map((lit) => ({
@@ -70,17 +69,12 @@ export class OcatParser extends CstParser {
 	});
 
 	public variableStatement = this.RULE("variableStatement", () => {
-		this.OPTION(() => {
-			this.OR([
-				{ ALT: () => this.CONSUME(token.Set, { LABEL: "Set" }) },
-				{ ALT: () => this.CONSUME(token.Const, { LABEL: "Const" }) },
-			]);
-		});
-		const type = this.CONSUME(token.VarType).image as ValueType;
-		this.CONSUME(token.Identifier);
+
+		const typeToken = this.CONSUME(token.VarType);
+		const idToken = this.CONSUME(token.Identifier);
 		this.CONSUME(token.Assign);
 
-		switch (type) {
+		switch (typeToken.image as ValueType) {
 			case ValueType.String:
 				this.CONSUME(token.StringLiteral);
 				break;
@@ -91,11 +85,26 @@ export class OcatParser extends CstParser {
 				this.CONSUME(token.BooleanLiteral);
 				break;
 		}
+
+		return {
+			typeToken, idToken
+		};
 	});
 
 	public functionStatement = this.RULE("functionStatement", () => {
-		this.CONSUME(token.Function);
-		this.CONSUME(token.Identifier);
+		const funcKeyword = this.CONSUME(token.Function);
+		const idToken = this.CONSUME(token.Identifier);
+
+		this.CONSUME(token.LeftParen);
+		this.MANY_SEP({
+			SEP: token.Comma,
+			DEF: () => {
+				this.CONSUME(token.VarType);
+				this.CONSUME2(token.Identifier);
+			},
+		});
+		this.CONSUME(token.RightParen);
+
 		this.CONSUME(token.LeftBrace);
 		this.MANY(() => this.SUBRULE(this.statement));
 		this.CONSUME(token.RightBrace);
@@ -104,5 +113,19 @@ export class OcatParser extends CstParser {
 	public callStatement = this.RULE("callStatement", () => {
 		this.CONSUME(token.Call);
 		this.CONSUME(token.Identifier);
+
+		this.CONSUME(token.LeftParen);
+		this.MANY_SEP({
+			SEP: token.Comma,
+			DEF: () => {
+				this.OR([
+					...token.literals.map((lit) => ({
+						ALT: () => this.CONSUME(lit),
+					})),
+					{ ALT: () => this.CONSUME2(token.Identifier) },
+				]);
+			},
+		});
+		this.CONSUME(token.RightParen);
 	});
 }

package/src/core/runner/funcs/_base.ts

@@ -0,0 +1,3 @@
+import type { CoreContext } from "../../context/coreContext.js";
+
+export type RunnerFunc<T> = (statement: T, ctx: CoreContext) => void;

package/src/core/runner/funcs/functions.ts

@@ -0,0 +1,46 @@
+import { AlreadyDeclaredFunctionError } from "../../../shared/manager/errors/semantic/undefined/declared.js";
+import type {
+	CallStatement,
+	FunctionStatement,
+} from "../../ast/types/statements/index.js";
+import type { RunnerFunc } from "./_base.js";
+import { UndeclaredFunctionError } from "../../../shared/manager/errors/semantic/undefined/undeclared.js";
+import { run } from "../runner.js";
+
+export const functionStatement: RunnerFunc<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,
+	};
+};
+
+export const callStatement: RunnerFunc<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, funcData.scope);
+};

package/src/core/runner/funcs/io.ts

@@ -0,0 +1,38 @@
+import { UndeclaredVariableError } from "../../../shared/manager/errors/semantic/undefined/undeclared.js";
+import { ValueType } from "../../../shared/models/value.js";
+import type { PrintStatement } from "../../ast/types/statements/index.js";
+import { solveString } from "../utils/string.js";
+import * as ctx from "../../../shared/context/globalContext.js";
+import type { RunnerFunc } from "./_base.js";
+
+export const printStatement: RunnerFunc<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.getService("log");
+	info?.info(val);
+};

package/src/core/runner/funcs/modules.ts

@@ -0,0 +1,17 @@
+import { execute } from "../../index.js";
+import type { ImportStatement } from "../../ast/types/statements/index.js";
+import type { RunnerFunc } from "./_base.js";
+import fs from "fs";
+
+export const importStatement: RunnerFunc<ImportStatement> = (
+	statement,
+	context,
+) => {
+	const fctx = execute(fs.readFileSync(statement.path).toString());
+	for (const [key, value] of Object.entries(fctx.variables)) {
+		context.variables[key] = value;
+	}
+	for (const [key, value] of Object.entries(fctx.functions)) {
+		context.functions[key] = value;
+	}
+};

package/src/core/runner/funcs/variables.ts

@@ -0,0 +1,57 @@
+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 type { VariableStatement } from "../../ast/types/statements/index.js";
+import { solveString } from "../utils/string.js";
+import type { RunnerFunc } from "./_base.js";
+
+export const variableStatement: RunnerFunc<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: string = 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/src/core/runner/runner.ts

@@ -1,133 +1,39 @@
-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, type CoreContext } from "../context/coreContext.js";
-import { ValueType } from "../../shared/models/value.js";
-import { solveString } from "./utils/string.js";
-import type { AnyStatement, CallStatement, FunctionStatement, PrintStatement, VariableStatement } from "../ast/types/statements/index.js";
+import type {
+	AnyStatement,
+	CallStatement,
+	FunctionStatement,
+	PrintStatement,
+	VariableStatement,
+} from "../ast/types/statements/index.js";
 import { StatementKind } from "../ast/types/base/statement.js";
-import * as ctx from "../../shared/context/globalContext.js";
+import type { RunnerFunc } from "./funcs/_base.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";
+import type { CoreContext } from "../context/coreContext.js";
+
+const statementMap = new Map<StatementKind, RunnerFunc<any>>([
+	[StatementKind.PrintStatement, printStatement],
+	[StatementKind.VariableStatement, variableStatement],
+	[StatementKind.FunctionStatement, functionStatement],
+	[StatementKind.CallStatement, callStatement],
+]);
 
 export function run(ast: AnyStatement[], context: CoreContext) {
-
 	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;
-		}
-	}
-}
-
-function printStatement(statement: PrintStatement, context: CoreContext) {
-	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: VariableStatement, context: CoreContext) {
-	const varId = statement.id;
+		const runner = statementMap.get(statement.kind);
 
-	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
-			);
+		if (!runner) {
+			throw new Error(`No runner for statement kind: ${statement.kind}`);
 		}
-	} else if (!statement.var.props.isConst) {
-		if (context.variables[varId]) {
-			new AlreadyDeclaredVariableError(varId).throw(
-				statement.sourceInfo.startLine
-			);
-		}
-	}
-
-	let value: string = 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: FunctionStatement, context: CoreContext) {
-	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: CallStatement, context: CoreContext) {
-	const funcId = statement.id
-	if (!funcId) return;
 
-	const funcData = context.functions[funcId];
-	if (!funcData) {
-		new UndeclaredFunctionError(funcId).throw(statement.sourceInfo.startLine);
+		runner(statement, context);
 	}
-	run(funcData.body, context.functions[funcId].scope);
-}
+	return context;
+}

package/src/core/services/log.service.ts

@@ -10,7 +10,7 @@ export interface Log {
 	level: LogLevel;
 }
 
-export interface LoggerConfig { 
+export interface LoggerConfig {
 	interceptors: {
 		onLog: (message: string) => string;
 		level: LogLevel;
@@ -26,52 +26,60 @@ export class LoggerService {
 		this.config = config;
 	}
 
-	log (message: string, level: LogLevel = LogLevel.Info) {
+	log(message: string, level: LogLevel = LogLevel.Info, printMsg: string = 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: string) {
+	debug(message: string) {
 		this.log(message, LogLevel.Debug);
 	}
 
-	info (message: string) {
+	info(message: string) {
 		this.log(message, LogLevel.Info);
 	}
 
-	warning (message: string) {
+	warning(message: string) {
 		this.log(message, LogLevel.Warning);
 	}
 
-	error (message: string) {
+	error(message: string) {
 		this.log(message, LogLevel.Error);
 	}
 
-	getLogs () {
+	getLogs() {
 		return this.logs;
 	}
 
-	pushInterceptor (interceptor: { onLog: (message: string) => string, level: LogLevel }) {
+	pushInterceptor(interceptor: {
+		onLog: (message: string) => string;
+		level: LogLevel;
+	}) {
 		this.config.interceptors.push(interceptor);
 	}
 
-	removeInterceptor (interceptor: { onLog: (message: string) => string, level: LogLevel }) {
-		this.config.interceptors = this.config.interceptors.filter(i => i !== interceptor);
+	removeInterceptor(interceptor: {
+		onLog: (message: string) => string;
+		level: LogLevel;
+	}) {
+		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: LoggerConfig = {
 	interceptors: [],
 	logs: [LogLevel.Debug, LogLevel.Info],
-};
+};

package/src/shared/context/globalContext.ts

@@ -1,8 +1,19 @@
+import type { LoggerService } from "../../core/services/log.service.js";
+
 export interface Context {
 	[key: string]: any;
+	services: Map<string, any>;
 }
 
-let globalContext: Context = {};
+let globalContext: Context = { services: new Map() };
+
+export function pushService(service: any, name: string) {
+	globalContext.services.set(name, service);
+}
+
+export function getService(name: string) {
+	return globalContext.services.get(name);
+}
 
 export function get(key: string) {
 	return globalContext[key];

package/src/shared/manager/baseManager.ts

@@ -7,12 +7,14 @@ export class OcatManager {
 	public message: string;
 	public color: ChalkInstance;
 	public level: LogLevel;
+	public printFn: (message: string) => void;
 
 	constructor(name: string, color: ChalkInstance, level: LogLevel) {
 		this.name = name;
 		this.message = "";
 		this.color = color;
 		this.level = level;
+		this.printFn = console.log;
 	}
 
 	toString(line: number | undefined = undefined): string {
@@ -31,9 +33,9 @@ export class OcatManager {
 	}
 
 	throw(line: number | undefined = undefined): never {
-		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/src/shared/manager/warn/coreWarnings.ts

@@ -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: string) {

package/src/shared/models/func.ts

@@ -11,4 +11,4 @@ export interface Param {
 export interface Function {
 	body: AnyStatement[];
 	scope: CoreContext;
-}
+}

package/tsconfig.json

@@ -3,13 +3,13 @@
 		// Enable latest features
 		"lib": ["ESNext", "DOM"],
 		"target": "ESNext",
-		"module": "ESNext",
+
+		"module": "nodenext",
+		"moduleResolution": "nodenext",
 		"moduleDetection": "force",
 		"jsx": "react-jsx",
 		"allowJs": true,
 
-		// Bundler mode
-		"moduleResolution": "bundler",
 		"verbatimModuleSyntax": true,
 
 		// Best practices

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

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