oclang 0.3.0

package/.editorconfig

@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = tab
+tab_width = 4
+end_of_line = crlf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## System version
+
+MAJOR.MINOR.PATCH
+
+MAJOR version when you make incompatible and breaking changes,
+MINOR version when you add functionality in a backwards-compatible manner, and
+PATCH version when you make backwards-compatible bug fixes.
+
+## 0.1.0 - Output
+
+- Initial release
+- Basic output `print("Hello World")`
+- Basic variable declaration `number x = 10`
+- Basic printing of variables `print(x)`
+
+## 0.2.0 - Variables
+
+- Basic variable modification `set number x = 20`
+
+## 0.3.0 - Generics
+
+- Error and warning handling system
+- Functions
+- Constants and set. Constants can't be modified
+-> AST added

package/README.md

@@ -0,0 +1,15 @@
+# ocat_lang
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run src/index.ts
+```
+
+This project was created using `bun init` in bun v1.1.33. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "oclang",
+  "version": "0.3.0",
+  "description": "A programming language",
+  "author": "LuisRG-L, Orange Cat",
+  "license": "MIT",
+  "type": "module",
+  "module": "src/index.ts",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "chevrotain": "^11.0.3"
+  }
+}

package/src/core/ast/astBuilder.ts

@@ -0,0 +1,172 @@
+import {
+	AlreadyDeclaredFunctionError,
+	AlreadyDeclaredVariableError,
+	CantModifyConstError,
+} from "../../shared/manager/errors/semantic/undefined/declared.js";
+import {
+	UndeclaredFunctionError,
+	UndeclaredVariableError,
+} from "../../shared/manager/errors/semantic/undefined/undeclared.js";
+import { 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 { isNoSubstitutionTemplateLiteral } from "typescript";
+
+export type BuildType = AnyStatement | null;
+
+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;
+
+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;
+		}
+
+		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;
+}
+
+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 = funcStmt.children.statement ?? [];
+		return {
+			kind: StatementKind.FunctionStatement,
+			sourceInfo: {
+				tokens: funcStmt.children,
+				cstNode: funcStmt,
+				startLine: funcStmt.startLine,
+				endLine: funcStmt.endLine,
+				startColumn: funcStmt.startColumn,
+				endColumn: funcStmt.endColumn,
+			},
+			id,
+			body,
+		}
+	}
+	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
+}

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

@@ -0,0 +1,2 @@
+export * from "./statement";
+export * from "./source";

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

@@ -0,0 +1,12 @@
+import type { CstNode, IToken } from "chevrotain";
+
+export interface SourceInfo {
+	startLine: number;
+	endLine: number;
+
+	startColumn: number;
+	endColumn: number;
+
+	tokens: IToken[];
+	cstNode?: CstNode;
+}

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

@@ -0,0 +1,13 @@
+import type { SourceInfo } from "./source";
+
+export enum StatementKind {
+	PrintStatement,
+	VariableStatement,
+	FunctionStatement,
+	CallStatement,
+}
+
+export interface Statement {
+	kind: StatementKind;
+	sourceInfo: SourceInfo;
+}

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

@@ -0,0 +1,6 @@
+import type { Statement, StatementKind } from "../base";
+
+export interface CallStatement extends Statement {
+	kind: StatementKind.CallStatement;
+	id: string;
+}

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

@@ -0,0 +1,16 @@
+import type { Statement, StatementKind } from "../base";
+import type { CallStatement } from "./callStatement";
+import type { PrintStatement } from "./printStatement";
+import type { VariableStatement } from "./variableStatement";
+
+export type AnyStatement =
+	| PrintStatement
+	| VariableStatement
+	| FunctionStatement
+	| CallStatement;
+
+export interface FunctionStatement extends Statement {
+	kind: StatementKind.FunctionStatement;
+	id: string;
+	body: AnyStatement[];
+}

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

@@ -0,0 +1,4 @@
+export * from "./printStatement";
+export * from "./variableStatement";
+export * from "./functionStatement";
+export * from "./callStatement";

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

@@ -0,0 +1,8 @@
+import type { Value } from "../../../../shared/models/value";
+import type { Statement, StatementKind } from "../base";
+
+
+export interface PrintStatement extends Statement {
+	kind: StatementKind.PrintStatement;
+	value: Value;
+}

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

@@ -0,0 +1,9 @@
+import type { Variable } from "../../../../shared/models/var";
+import type { Statement, StatementKind } from "../base";
+
+export interface VariableStatement extends Statement {
+	kind: StatementKind.VariableStatement;
+	id: string;
+	var: Variable;
+	set: boolean;
+}

package/src/core/context/contextType.ts

@@ -0,0 +1,4 @@
+export enum ContextType {
+	Variable = "Variable",
+	Function = "Function",
+}

package/src/core/context/coreContext.ts

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

package/src/core/index.ts

@@ -0,0 +1,17 @@
+import { ocatLexer } from "./lexer/tokens";
+import { OcatParser } from "./parser/parser";
+import { run } from "./runner/runner";
+import { createCoreContext } from "./context/coreContext";
+import { buildAst } from "./ast/astBuilder";
+
+export function execute(code: string) {
+	const lexingResult = ocatLexer.tokenize(code);
+
+	const parser = new OcatParser();
+	parser.input = lexingResult.tokens;
+	const cst = parser.program();
+	const ast = buildAst(cst, );
+
+	const context = createCoreContext();
+	run(ast, context);
+}

package/src/core/lexer/tokens/attrs.ts

@@ -0,0 +1,8 @@
+import { createToken, Lexer } from "chevrotain";
+
+export const Const = createToken({
+	name: "Const",
+	pattern: /const/,
+});
+
+export const attributes = [Const];

package/src/core/lexer/tokens/comments.ts

@@ -0,0 +1,14 @@
+import { createToken, Lexer } from "chevrotain";
+
+export const LineComment = createToken({
+	name: "LineComment",
+	pattern: /\/\/[^\n]*/,
+	group: Lexer.SKIPPED,
+});
+export const BlockComment = createToken({
+	name: "BlockComment",
+	pattern: /\/\*[\s\S]*?\*\//,
+	group: Lexer.SKIPPED,
+});
+
+export const comments = [LineComment, BlockComment];

package/src/core/lexer/tokens/delimiters.ts

@@ -0,0 +1,15 @@
+import { createToken } from "chevrotain";
+
+export const LeftParen = createToken({ name: "LeftParen", pattern: /\(/ });
+export const RightParen = createToken({ name: "RightParen", pattern: /\)/ });
+
+export const LeftBrace = createToken({ name: "LeftBrace", pattern: /\{/ });
+export const RightBrace = createToken({ name: "RightBrace", pattern: /\}/ });
+
+export const LeftBracket = createToken({ name: "LeftBracket", pattern: /\[/ });
+export const RightBracket = createToken({ name: "RightBracket", pattern: /\]/ });
+
+export const LeftTag = createToken({ name: "LeftTag", pattern: /</ });
+export const RightTag = createToken({ name: "RightTag", pattern: />/ });
+
+export const delimiters = [LeftParen, RightParen, LeftBrace, RightBrace, LeftBracket, RightBracket, LeftTag, RightTag];

package/src/core/lexer/tokens/function.ts

@@ -0,0 +1,13 @@
+import { createToken } from "chevrotain";
+
+export const Function = createToken({
+	name: "Function",
+	pattern: /func/,
+});
+
+export const Call = createToken({
+	name: "Call",
+	pattern: /call/,
+});
+
+export const functions = [Function, Call];

package/src/core/lexer/tokens/ignored.ts

@@ -0,0 +1,5 @@
+import { createToken } from "chevrotain";
+
+export const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /\s+/ });
+
+export const ignored = [WhiteSpace];

package/src/core/lexer/tokens/index.ts

@@ -0,0 +1,31 @@
+export * from "./ignored.js";
+export * from "./comments.js";
+export * from "./keywords.js";
+export * from "./literals.js";
+export * from "./delimiters.js";
+export * from "./vars.js";
+export * from "./operators.js";
+export * from "./attrs.js";
+export * from "./function.js";
+
+import { ignored } from "./ignored.js";
+import { comments } from "./comments.js";
+import { keywords } from "./keywords.js";
+import { literals } from "./literals.js";
+import { delimiters } from "./delimiters.js";
+import { variablesAndConstants } from "./vars.js";
+import { operators } from "./operators.js";
+import { attributes } from "./attrs.js";
+import { functions } from "./function.js";
+
+export const allTokens = [
+	...ignored,
+	...comments,
+	...keywords,
+	...attributes,
+	...functions,
+	...literals,
+	...delimiters,
+	...variablesAndConstants,
+	...operators,
+];

package/src/core/lexer/tokens/keywords.ts

@@ -0,0 +1,5 @@
+import { createToken } from "chevrotain";
+
+export const Output = createToken({ name: "Output", pattern: /print/ });
+
+export const keywords = [Output];

package/src/core/lexer/tokens/literals.ts

@@ -0,0 +1,16 @@
+import { createToken } from "chevrotain";
+
+export const StringLiteral = createToken({
+	name: "StringLiteral",
+	pattern: /"(?:[^\\"]|\\.)*"/,
+});
+export const NumberLiteral = createToken({
+	name: "NumberLiteral",
+	pattern: /\d+(\.\d+)?/,
+});
+export const BooleanLiteral = createToken({
+	name: "BooleanLiteral",
+	pattern: /true|false/,
+});
+
+export const literals = [StringLiteral, NumberLiteral, BooleanLiteral];

package/src/core/lexer/tokens/operators.ts

@@ -0,0 +1,5 @@
+import { createToken } from "chevrotain";
+
+export const Assign = createToken({ name: "Assign", pattern: /=/ });
+
+export const operators = [Assign];

package/src/core/lexer/tokens/vars.ts

@@ -0,0 +1,14 @@
+import { createToken } from "chevrotain";
+import { ValueType } from "../../../shared/models/value.js";
+
+export const VarType = createToken({
+	name: "VarType",
+	pattern: new RegExp(Object.values(ValueType).join("|")),
+});
+export const Set = createToken({ name: "Set", pattern: /set/ });
+export const Identifier = createToken({
+	name: "Identifier",
+	pattern: /[a-zA-Z_]\w*/,
+});
+
+export const variablesAndConstants = [VarType, Set, Identifier];

package/src/core/lexer/tokens.ts

@@ -0,0 +1,4 @@
+import { Lexer } from "chevrotain";
+import { allTokens } from "./tokens/index.js";
+
+export const ocatLexer = new Lexer(allTokens);

package/src/core/parser/parser.ts

@@ -0,0 +1,97 @@
+import { CstParser } from "chevrotain";
+import { ValueType } from "../../shared/models/value.js";
+import * as token from "../lexer/tokens/index.js";
+
+export class OcatParser extends CstParser {
+	constructor() {
+		super(token.allTokens, {
+			recoveryEnabled: true,
+		});
+		this.performSelfAnalysis();
+	}
+
+	public program = this.RULE("program", () => {
+		this.MANY(() => this.SUBRULE(this.statement));
+	});
+
+	public statement = this.RULE("statement", () => {
+		this.OR([
+			{
+				ALT: () =>
+					this.SUBRULE(this.printStatement, {
+						LABEL: "printStatement",
+					}),
+			},
+			{
+				ALT: () =>
+					this.SUBRULE(this.variableStatement, {
+						LABEL: "variableStatement",
+					}),
+			},
+			{
+				ALT: () =>
+					this.SUBRULE(this.functionStatement, {
+						LABEL: "functionStatement",
+					}),
+			},
+			{
+				ALT: () =>
+					this.SUBRULE(this.callStatement, {
+						LABEL: "callStatement",
+					}),
+			},
+		]);
+	});
+
+	public printStatement = this.RULE("printStatement", () => {
+		this.CONSUME(token.Output);
+		this.CONSUME(token.LeftParen);
+		this.OR([
+			...token.literals.map((lit) => ({
+				ALT: () => this.CONSUME(lit, { LABEL: lit.name }),
+			})),
+			{
+				ALT: () =>
+					this.CONSUME(token.Identifier, { LABEL: "Identifier" }),
+			},
+		]);
+		this.CONSUME(token.RightParen);
+	});
+
+	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);
+		this.CONSUME(token.Assign);
+
+		switch (type) {
+			case ValueType.String:
+				this.CONSUME(token.StringLiteral);
+				break;
+			case ValueType.Number:
+				this.CONSUME(token.NumberLiteral);
+				break;
+			case ValueType.Boolean:
+				this.CONSUME(token.BooleanLiteral);
+				break;
+		}
+	});
+
+	public functionStatement = this.RULE("functionStatement", () => {
+		this.CONSUME(token.Function);
+		this.CONSUME(token.Identifier);
+		this.CONSUME(token.LeftBrace);
+		this.MANY(() => this.SUBRULE(this.statement));
+		this.CONSUME(token.RightBrace);
+	});
+
+	public callStatement = this.RULE("callStatement", () => {
+		this.CONSUME(token.Call);
+		this.CONSUME(token.Identifier);
+	});
+}

package/src/core/runner/runner.ts

@@ -0,0 +1,128 @@
+import {
+	AlreadyDeclaredFunctionError,
+	AlreadyDeclaredVariableError,
+	CantModifyConstError,
+} from "../../shared/manager/errors/semantic/undefined/declared.js";
+import {
+	UndeclaredFunctionError,
+	UndeclaredVariableError,
+} from "../../shared/manager/errors/semantic/undefined/undeclared.js";
+import { 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 { StatementKind } from "../ast/types/base/statement.js";
+
+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;
+	}
+	console.log(val);
+}
+
+function variableStatement(statement: VariableStatement, context: CoreContext) {
+	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,
+		},
+	};
+}
+
+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.body ?? [];
+	context.functions[idToken] = {
+		body,
+	};
+}
+
+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);
+	}
+	run(funcData.body, context);
+}

package/src/core/runner/utils/string.ts

@@ -0,0 +1,19 @@
+import { OcatError } from "../../../shared/manager/errors/coreErrors";
+import { UndeclaredVariableError } from "../../../shared/manager/errors/semantic/undefined/undeclared";
+import type { CoreContext } from "../../context/coreContext";
+
+export function solveString(input: string, context: CoreContext, err: (err: OcatError) => void): string {
+	let str: string = input;
+
+	str = str.slice(1, -1);
+
+	str = str.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+		const value = context.variables[varName.trim()];
+		if (!value) {
+			err(new UndeclaredVariableError(varName.trim()));
+		}
+		return value?.value ?? "";
+	});
+
+	return str;
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import { execute } from "./core/index.js";
+
+// Example usage
+const code = `
+print("red")
+`;
+
+execute(code);

package/src/shared/manager/baseManager.ts

@@ -0,0 +1,24 @@
+import chalk, { type ChalkInstance } from "chalk";
+
+export class OcatManager {
+	public name: string;
+	public message: string;
+	public color: ChalkInstance;
+
+	constructor(name: string, color: ChalkInstance) {
+		this.name = name;
+		this.message = "";
+		this.color = color;
+	}
+
+	toString(line: number | undefined = undefined): string {
+		return `${this.color.bold(this.name)} ${
+			line && chalk.gray(`at line ${line}`)
+		}: ${this.color.italic(this.message)}`;
+	}
+
+	throw(line: number) {
+		console.log(this.toString(line));
+		process.exit(1);
+	}
+}

package/src/shared/manager/errors/api/index.ts

@@ -0,0 +1,2 @@
+export * from "./throw.js";
+export * from "./types.js";

package/src/shared/manager/errors/api/throw.ts

@@ -0,0 +1,5 @@
+import type { OcatError } from "../coreErrors";
+
+export function throwErr(error: OcatError) {
+	console.log(error.toString());
+}

package/src/shared/manager/errors/api/types.ts

@@ -0,0 +1,5 @@
+import { OcatError } from "../coreErrors";
+
+export function isOcatError(obj: any) {
+	return obj instanceof OcatError;
+}

package/src/shared/manager/errors/coreErrors.ts

@@ -0,0 +1,10 @@
+import chalk from "chalk";
+import { OcatManager } from "../baseManager";
+
+export class OcatError extends OcatManager {
+	constructor(name: string) {
+		super(name, chalk.red);
+	}
+}
+
+export * from "./api";

package/src/shared/manager/errors/semantic/undefined/declared.ts

@@ -0,0 +1,28 @@
+import { ContextType } from "../../../../../core/context/contextType";
+import { OcatError } from "../../coreErrors";
+
+export class AlreadyDeclaredError extends OcatError {
+	constructor(varName: string, type: ContextType) {
+		super(`Already declared ${type.toLowerCase()}`);
+		this.message = `${type} ${varName} is already declared`;
+	}
+}
+
+export class AlreadyDeclaredVariableError extends AlreadyDeclaredError {
+	constructor(varName: string) {
+		super(varName, ContextType.Variable);
+	}
+}
+
+export class AlreadyDeclaredFunctionError extends AlreadyDeclaredError {
+	constructor(varName: string) {
+		super(varName, ContextType.Function);
+	}
+}
+
+export class CantModifyConstError extends OcatError {
+	constructor(varName: string) {
+		super(`Can't modify const variable`);
+		this.message = `Variable ${varName} is const and can't be modified`;
+	}
+}

package/src/shared/manager/errors/semantic/undefined/undeclared.ts

@@ -0,0 +1,21 @@
+import { ContextType } from "../../../../../core/context/contextType";
+import { OcatError } from "../../coreErrors";
+
+export class UndeclaredError extends OcatError {
+	constructor(varName: string, type: ContextType) {
+		super(`Undeclared ${type.toLowerCase()}`);
+		this.message = `${type} ${varName} is not declared`;
+	}
+}
+
+export class UndeclaredVariableError extends UndeclaredError {
+	constructor(varName: string) {
+		super(varName, ContextType.Variable);
+	}
+}
+
+export class UndeclaredFunctionError extends UndeclaredError {
+	constructor(varName: string) {
+		super(varName, ContextType.Function);
+	}
+}

package/src/shared/manager/errors/syntax/syntaxErrors.ts

@@ -0,0 +1,8 @@
+import { OcatError } from "../coreErrors.js";
+
+export class SyntaxError extends OcatError {
+	constructor(message: string) {
+		super("SyntaxError");
+		this.message = message;
+	}
+}

package/src/shared/manager/errors/syntax/token.ts

@@ -0,0 +1,13 @@
+import { SyntaxError } from "./syntaxErrors.js";
+
+export class UndefinedToken extends SyntaxError {
+	constructor() {
+		super(`Undefined token`);
+	}
+}
+
+export class UnexpectedToken extends SyntaxError {
+	constructor(token: string) {
+		super(`Unexpected token: ${token}`);
+	}
+}

package/src/shared/manager/warn/coreWarnings.ts

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+import { OcatManager } from "../baseManager";
+
+export class OcatWarning extends OcatManager {
+	constructor(name: string) {
+		super(name, chalk.yellow);
+	}
+}

package/src/shared/models/func.ts

@@ -0,0 +1,5 @@
+import type { AnyStatement } from "../../core/ast/types/statements/index.js";
+
+export interface Function {
+	body: AnyStatement[];
+}

package/src/shared/models/value.ts

@@ -0,0 +1,11 @@
+export enum ValueType {
+	String = "string",
+	Number = "number",
+	Boolean = "bool",
+	Identifier = "identifier",
+}
+
+export interface Value {
+	value: string;
+	type: ValueType;
+}

package/src/shared/models/var.ts

@@ -0,0 +1,7 @@
+export interface Variable {
+	type: string;
+	value: string;
+	props: {
+		isConst: boolean;
+	}
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}