oclang 1.2.2 → 1.3.2

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

@@ -0,0 +1,46 @@
+import type { ValueType } from "../../../shared/models/value.js";
+import { StatementKind } from "../types/base/index.js";
+import type { VariableStatement } from "../types/statements/index.js";
+import type { FBuilder } from "./_base.js";
+
+const variableStatement: FBuilder<VariableStatement> = (statement: any) => {
+	const varStmt = statement.children.variableStatement?.[0];
+	if (!varStmt) return null;
+
+	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 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: false,
+			},
+		},
+		set: false,
+	};
+};
+
+export const variableStatements = [variableStatement];

package/src/core/ast/types/base/statement.ts

@@ -1,10 +1,11 @@
-import type { SourceInfo } from "./source";
+import type { SourceInfo } from "./source.js";
 
 export enum StatementKind {
 	PrintStatement,
 	VariableStatement,
 	FunctionStatement,
 	CallStatement,
+	ImportStatement,
 }
 
 export interface Statement {

package/src/core/ast/types/statements/callStatement.ts

@@ -1,5 +1,4 @@
-import type { Value } from "../../../../shared/models/value";
-import type { Statement, StatementKind } from "../base";
+import type { Statement, StatementKind } from "../base/index.js";
 
 export interface CallStatement extends Statement {
 	kind: StatementKind.CallStatement;

package/src/core/ast/types/statements/functionStatement.ts

@@ -1,5 +1,5 @@
-import type { Statement, StatementKind } from "../base";
-import type { Function } from "../../../../shared/models/func";
+import type { Statement, StatementKind } from "../base/index.js";
+import type { Function } from "../../../../shared/models/func.js";
 
 export interface FunctionStatement extends Statement {
 	kind: StatementKind.FunctionStatement;

package/src/core/ast/types/statements/importStatement.ts

@@ -0,0 +1,6 @@
+import type { StatementKind } from "../base/index.js";
+
+export interface ImportStatement {
+	kind: StatementKind.ImportStatement;
+	path: string;
+}

package/src/core/ast/types/statements/index.ts

@@ -1,16 +1,19 @@
-import type { FunctionStatement } from "./functionStatement";
-import type { PrintStatement } from "./printStatement";
-import type { VariableStatement } from "./variableStatement";
-import type { CallStatement } from "./callStatement";
+import type { FunctionStatement } from "./functionStatement.js";
+import type { PrintStatement } from "./printStatement.js";
+import type { VariableStatement } from "./variableStatement.js";
+import type { CallStatement } from "./callStatement.js";
+import type { ImportStatement } from "./importStatement.js";
 
-export * from "./printStatement";
-export * from "./variableStatement";
-export * from "./functionStatement";
-export * from "./callStatement";
+export * from "./printStatement.js";
+export * from "./variableStatement.js";
+export * from "./functionStatement.js";
+export * from "./callStatement.js";
+export * from "./importStatement.js";
 
 
 export type AnyStatement =
 	| PrintStatement
 	| VariableStatement
 	| FunctionStatement
-	| CallStatement;
+	| CallStatement
+	| ImportStatement;

package/src/core/ast/types/statements/printStatement.ts

@@ -1,5 +1,5 @@
-import type { Value } from "../../../../shared/models/value";
-import type { Statement, StatementKind } from "../base";
+import type { Value } from "../../../../shared/models/value.js";
+import type { Statement, StatementKind } from "../base/index.js";
 
 
 export interface PrintStatement extends Statement {

package/src/core/ast/types/statements/variableStatement.ts

@@ -1,5 +1,5 @@
-import type { Variable } from "../../../../shared/models/var";
-import type { Statement, StatementKind } from "../base";
+import type { Variable } from "../../../../shared/models/var.js";
+import type { Statement, StatementKind } from "../base/index.js";
 
 export interface VariableStatement extends Statement {
 	kind: StatementKind.VariableStatement;

package/src/core/context/coreContext.ts

@@ -1,5 +1,5 @@
-import type { Variable } from "../../shared/models/var";
-import type { Function } from "../../shared/models/func";
+import type { Variable } from "../../shared/models/var.js";
+import type { Function } from "../../shared/models/func.js";
 
 export interface CoreContext {
 	variables: Record<string, Variable>;	
@@ -11,4 +11,4 @@ export function createCoreContext(): CoreContext {
 		variables: {},
 		functions: {},
 	};
-}
+}

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/lexer/tokens/keywords.ts

@@ -2,4 +2,6 @@ import { createToken } from "chevrotain";
 
 export const Output = createToken({ name: "Output", pattern: /print/ });
 
-export const keywords = [Output];
+export const Import = createToken({ name: "Import", pattern: /import/ });
+
+export const keywords = [Output, Import];

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();
 	}
 
@@ -16,6 +14,12 @@ export class OcatParser extends CstParser {
 
 	public statement = this.RULE("statement", () => {
 		this.OR([
+			{
+				ALT: () =>
+					this.SUBRULE(this.importStatement, {
+						LABEL: "importStatement",
+					}),
+			},
 			{
 				ALT: () =>
 					this.SUBRULE(this.printStatement, {
@@ -43,8 +47,14 @@ export class OcatParser extends CstParser {
 		]);
 	});
 
+	public importStatement = this.RULE("importStatement", () => {
+		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) => ({
@@ -59,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;
@@ -80,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);
@@ -93,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;
+}