oclang 1.2.1 → 1.2.3

package/BUG_REGISTRY.md

@@ -8,6 +8,7 @@ BUG-\<BUG-NUMBER>\<BUG-PART>-\<VERSION>-\<VERSION-FORMAT>
 
 - BUG-002A-100-MmP: CLI always uses force mode
 - BUG-002B-101-MmP: The errors in the CLI shows 'undefined'
+- BUG-002C-100-MmP: Dist folder is not created
 
 ## 0.3.0 bugs
 

package/CHANGELOG.md

@@ -16,15 +16,22 @@ PATCH version when you make backwards-compatible bug fixes.
 
 - OCM mode added
 
-#### 1.2.1 - Uploading error
+#### 1.2.3 - AST Structure
+
+- AST Structure updated
+
+#### 1.2.1 & 1.2.2 - Uploading error
 
 - Uploading error in 1.2.0
-- Updated the CLI ```ocm init``` command
 
 ### 1.1.0 - REPL
 
 - REPL mode added
 
+#### 1.1.2 - BUG-002C-100-MmP
+
+- BUG-002C-100-MmP: Dist folder is not created
+
 #### 1.1.1 - BUG-002B-101-MmP
 
 - BUG-002B-100-MmP: The errors in the CLI shows 'undefined'

package/dist/cli/index.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/ocat/commands/index.js

@@ -0,0 +1,2 @@
+export * from "./run.js";
+export * from "./repl.js";

package/dist/cli/ocat/commands/repl.js

@@ -0,0 +1,39 @@
+import readline from "readline";
+import chalk from "chalk";
+import { execute } from "../../../core/index.js";
+export function repl() {
+    console.log(chalk.yellow("Orange Cat REPL v1.0.0"));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.cyan("ocat> "),
+    });
+    rl.prompt();
+    rl.on("line", (line) => {
+        const input = line.trim();
+        // comandos internos
+        if (input === ".exit") {
+            rl.close();
+            return;
+        }
+        if (input === ".help") {
+            console.log(`
+.exit     Exit REPL
+.clear    Clear screen
+      `);
+            rl.prompt();
+            return;
+        }
+        if (input === ".clear") {
+            console.clear();
+            rl.prompt();
+            return;
+        }
+        execute(input);
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        console.log("\nBye!");
+        process.exit(0);
+    });
+}

package/dist/cli/ocat/commands/run.js

@@ -0,0 +1,19 @@
+import { execute } from "../../../core/index.js";
+import { ExtensionError } from "../../../shared/manager/errors/io/extension.js";
+import chalk from "chalk";
+import fs from "fs";
+import { FileDoesntExistError } from "../../../shared/manager/errors/io/file.js";
+export function runfile(file, options) {
+    if (!file.endsWith(".ocat") && !options.force) {
+        new ExtensionError("File must be a .ocat file. Use -f to force execution with other extensions").throw();
+    }
+    if (options.force) {
+        console.log(chalk.blue(`Running in force mode`));
+    }
+    if (!fs.existsSync(file)) {
+        new FileDoesntExistError(`File ${file} doesn't exist`)
+            .throw();
+    }
+    const fileText = fs.readFileSync(file, "utf8");
+    execute(fileText);
+}

package/dist/cli/ocat/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { runfile } from "./commands/index.js";
+import { repl } from "./commands/index.js";
+const program = new Command();
+program
+    .name("ocat")
+    .description("The Orange Cat language compiler")
+    .version("1.0.0");
+program
+    .command("run")
+    .description("Run a file. This file must be a .ocat file")
+    .argument("<file>", "The file to run")
+    .option("-f, --force", "Force the execution with other extensions")
+    .action(runfile);
+program
+    .command("inline")
+    .description("An REPL for the Orange Cat language")
+    .action(repl);
+program.parse();

package/dist/cli/ocm/commands/index.js

@@ -0,0 +1,2 @@
+export * from "./init.js";
+export * from "./run.js";

package/dist/cli/ocm/commands/init.js

@@ -0,0 +1,41 @@
+import inquirer from "inquirer";
+import chalk, {} from "chalk";
+import { chalkText } from "../../utils/chalkText.js";
+import { createProject } from "../../../project/index.js";
+import { fromCamelToDash } from "../../../shared/utils/strformat.js";
+export async function init() {
+    const projectTypes = [{ name: "App", color: chalk.red }, { name: "Lib", color: chalk.yellow }];
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "name",
+            message: "How do you want to name your project?",
+            default: "myProject",
+        },
+        {
+            type: "input",
+            name: "dir",
+            message: "Where do you want to create your project?",
+            default: (answers) => answers.name,
+        },
+        {
+            type: "input",
+            name: "id",
+            message: "What is your project ID?",
+            default: (answers) => fromCamelToDash(answers.name),
+        },
+        {
+            type: "select",
+            name: "type",
+            message: "What type of project do you want to create?",
+            choices: projectTypes
+                .map((choice) => chalkText(choice.name, choice.color)),
+        }
+    ]);
+    createProject({
+        name: answers.name,
+        dir: answers.dir,
+        type: answers.type,
+        id: answers.id,
+    });
+}

package/dist/cli/ocm/commands/run.js

@@ -0,0 +1,17 @@
+import path from "path";
+import { readJSON } from "../../../shared/io/json.js";
+import { runfile } from "../../ocat/commands/index.js";
+import * as context from "../../../shared/context/globalContext.js";
+import { defaultLoggerConfig, LoggerService } from "../../../core/services/log.service.js";
+export function run() {
+    const projectConfig = readJSON(path.join(".ocat", "config.json"));
+    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/dist/cli/ocm/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { init, run } from "./commands/index.js";
+const program = new Command();
+program.name("ocm").description("The Orange Cat manager").version("1.0.0");
+program
+    .command("initialize")
+    .alias("init")
+    .description("Initialize a new Orange Cat project")
+    .action(async () => { await init(); });
+program
+    .command("run")
+    .description("Run the project")
+    .action(run);
+program.parse();

package/dist/cli/utils/chalkText.js

@@ -0,0 +1,6 @@
+export function chalkText(text, color) {
+    return {
+        name: color(text),
+        value: text
+    };
+}

package/dist/core/ast/astBuilder.js

@@ -0,0 +1,150 @@
+import { createCoreContext } from "../context/coreContext.js";
+import { ValueType } from "../../shared/models/value.js";
+import { StatementKind } from "./types/base/index.js";
+export function buildAst(cst) {
+    const statements = cst.children.statement ?? [];
+    const ast = [];
+    for (const statement of statements) {
+        let __tmp = 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;
+}
+const printStatement = (statement) => {
+    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;
+};
+const variableStatement = (statement) => {
+    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;
+        const id = idToken.image;
+        const value = 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 = (statement) => {
+    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 = (statement) => {
+    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/dist/core/ast/types/base/index.js

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

package/dist/core/ast/types/base/source.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ast/types/base/statement.js

@@ -0,0 +1,7 @@
+export var StatementKind;
+(function (StatementKind) {
+    StatementKind[StatementKind["PrintStatement"] = 0] = "PrintStatement";
+    StatementKind[StatementKind["VariableStatement"] = 1] = "VariableStatement";
+    StatementKind[StatementKind["FunctionStatement"] = 2] = "FunctionStatement";
+    StatementKind[StatementKind["CallStatement"] = 3] = "CallStatement";
+})(StatementKind || (StatementKind = {}));

package/dist/core/ast/types/statements/callStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ast/types/statements/functionStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ast/types/statements/index.js

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

package/dist/core/ast/types/statements/printStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ast/types/statements/variableStatement.js

@@ -0,0 +1 @@
+export {};

package/dist/core/context/contextType.js

@@ -0,0 +1,5 @@
+export var ContextType;
+(function (ContextType) {
+    ContextType["Variable"] = "Variable";
+    ContextType["Function"] = "Function";
+})(ContextType || (ContextType = {}));

package/dist/core/context/coreContext.js

@@ -0,0 +1,6 @@
+export function createCoreContext() {
+    return {
+        variables: {},
+        functions: {},
+    };
+}

package/dist/core/index.js

@@ -0,0 +1,22 @@
+import { ocatLexer } from "./lexer/tokens.js";
+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 fs from "fs";
+export function execute(code) {
+    const lexingResult = ocatLexer.tokenize(code);
+    const parser = new OcatParser();
+    parser.input = lexingResult.tokens;
+    const cst = parser.program();
+    const ast = buildAst(cst);
+    process.on("exit", () => {
+        if (ctx.get("isProject")) {
+            const logs = ctx.get("services").log.toString();
+            fs.writeFileSync(".ocat/logs.txt", logs);
+        }
+    });
+    const context = createCoreContext();
+    run(ast, context);
+}

package/dist/core/lexer/tokens/attrs.js

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

package/dist/core/lexer/tokens/comments.js

@@ -0,0 +1,12 @@
+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/dist/core/lexer/tokens/delimiters.js

@@ -0,0 +1,11 @@
+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 Comma = createToken({ name: "Comma", pattern: /,/ });
+export const delimiters = [LeftParen, RightParen, LeftBrace, RightBrace, LeftBracket, RightBracket, LeftTag, RightTag, Comma];

package/dist/core/lexer/tokens/function.js

@@ -0,0 +1,10 @@
+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/dist/core/lexer/tokens/ignored.js

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

package/dist/core/lexer/tokens/index.js

@@ -0,0 +1,29 @@
+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/dist/core/lexer/tokens/keywords.js

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

package/dist/core/lexer/tokens/literals.js

@@ -0,0 +1,14 @@
+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/dist/core/lexer/tokens/operators.js

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

package/dist/core/lexer/tokens/vars.js

@@ -0,0 +1,12 @@
+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/dist/core/lexer/tokens.js

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

package/dist/core/parser/parser.js

@@ -0,0 +1,84 @@
+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();
+    }
+    program = this.RULE("program", () => {
+        this.MANY(() => this.SUBRULE(this.statement));
+    });
+    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",
+                }),
+            },
+        ]);
+    });
+    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);
+    });
+    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;
+        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;
+        }
+    });
+    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);
+    });
+    callStatement = this.RULE("callStatement", () => {
+        this.CONSUME(token.Call);
+        this.CONSUME(token.Identifier);
+    });
+}