utkrisht 0.1.0

package/compiler/parser.js

@@ -0,0 +1,375 @@
+import * as logger from "./logger.js";
+
+export function createParser(tokens) {
+    return {
+        tokens,
+        position: 0,
+    };
+}
+
+class ParseError extends Error {
+    constructor(message, token) {
+        super(message);
+        this.token = token;
+        this.name = "ParseError";
+    }
+}
+
+function error(utkrisht, message, token) {
+    logger.error(utkrisht, message, token.line)
+    return new ParseError(message, token)
+}
+
+function getCurrentToken(parser) {
+    return parser.tokens[parser.position];
+}
+
+function getNextToken(parser) {
+    return parser.tokens[parser.position + 1];
+}
+
+function getTokenTypeAtPosition(parser, position) {
+    return parser.tokens[position];
+}
+
+function isCurrentTokenType(parser, ...types) {
+    for (const type of types) {
+        if (getCurrentToken(parser).type === type) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isNextTokenType(parser, ...types) {
+    for (const type of types) {
+        if (getNextToken(parser).type === type) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isTokenTypeAtPosition(parser, position, ...types) {
+    for (const type of types) {
+        if (getTokenTypeAtPosition(parser, position).type === type) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+function isAtEnd(parser) {
+    return parser.tokens[parser.position].type === "EndOfFile";
+}
+
+function ignoreToken(parser, ...tokens) {
+    if (isCurrentTokenType(parser, ...tokens)) {
+        parser.position++;
+    }
+}
+
+function expectToken(utkrisht, parser, ...tokens) {
+    if (isCurrentTokenType(parser, ...tokens)) {
+        return;
+    }
+
+    const expected =
+        tokens.length === 1
+            ? tokens[0]
+            : "one of [" + tokens.join(", ") + "]"
+        ;
+
+    const found =
+        isCurrentTokenType(parser, "EndOfFile")
+            ? "reached end of code"
+            : "got " + getCurrentToken(parser).type
+        ;
+
+    throw error(utkrisht, "Expected " + expected + ", but " + found, getCurrentToken(parser))
+}
+
+
+function synchronise(parser) {
+    while (!isAtEnd(parser)) {
+        parser.position++
+        // if (isCurrentTokenType(parser, "NewLine")) {
+        //     break;
+        // }
+        if (isCurrentTokenType(parser, "Loop", "When")) {
+            break;
+        }
+    }
+}
+
+
+function isCurrentTokenTypeExpressionStart(parser) {
+    return isCurrentTokenType(parser,
+        "NumericLiteral",
+        "StringLiteral",
+        "Right",
+        "Wrong",
+        "Identifier",
+        "LeftRoundBracket"
+    )
+}
+
+
+function parseVariableExpression(utkrisht, parser) {
+    if (parser.variableExpression !== undefined) {
+        parser.position = parser.variableExpressionEndPosition;
+        
+        parser.variableExpression = undefined;
+        parser.variableExpressionEndPosition = undefined;
+        
+        return parser.variableExpression;
+    }
+    const name = getCurrentToken(parser);
+    parser.position++;
+
+    const _arguments = [];
+    while (true) {
+        if (isCurrentTokenTypeExpressionStart(parser)) {
+            _arguments.push( { type: "Argument", name: undefined, value: parseExpression(utkrisht, parser) });
+
+            if (isCurrentTokenType(parser, "Comma")) {
+                parser.position++;
+                continue;
+            } else {
+                break;
+            }
+        }
+
+        if (isCurrentTokenType(parser, "Identifier") && isNextTokenType(parser, "Colon")) {
+            const name = getCurrentToken(parser);
+            parser.position++;
+            const value = parseExpression(utkrisht, parser);
+            _arguments.push({ type: "Argument", name, value });
+
+            if (isCurrentTokenType(parser, "Comma")) {
+                parser.position++;
+                continue;
+            } else {
+                break;
+            }
+        }
+
+        break;
+    }
+    
+    return { type: "VariableExpression", name, _arguments }
+}
+
+function parsePrimaryExpression(utkrisht, parser) {
+    let expression;
+
+    if (isCurrentTokenType(parser, "right")) {
+        expression = { type: "LiteralExpression", value: { type: "BooleanExpression", value: true }};
+        parser.position++;
+    } else if (isCurrentTokenType(parser, "wrong")) {
+        expression = { type: "LiteralExpression", value: { type: "BooleanExpression", value: false }};
+        parser.position++;
+    } else if (isCurrentTokenType(parser, "StringLiteral")) {
+        expression = { type: "LiteralExpression", value: { type: "StringLiteral", value: getCurrentToken(parser).lexeme }};
+        parser.position++;
+    } else if (isCurrentTokenType(parser, "NumericLiteral")) {
+        expression = { type: "LiteralExpression", value: { type: "NumericLiteral", value: Number(getCurrentToken(parser).lexeme) }};
+        parser.position++;
+    } else if (isCurrentTokenType(parser, "LeftRoundBracket")) {
+        parser.position++;
+        expression = { type: "GroupingExpression", expression: parseExpression(utkrisht, parser) };
+        expectToken(utkrisht, parser, "RightRoundBracket");
+        parser.position++;
+    } else if (isCurrentTokenType(parser, "Identifier")) {
+        expression = parseVariableExpression(utkrisht, parser);
+    } else {
+        throw error(
+            utkrisht, 
+            isCurrentTokenType(parser, "EndOfFile") 
+                ? "Expected an expression but reached end of code" 
+                : "Expected an expression but got " + getCurrentToken(parser).type
+            ,
+            getCurrentToken(parser)
+        );
+    }
+
+    return expression;
+}
+
+function parseUnaryExpression(utkrisht, parser) {
+    if (isCurrentTokenType(parser, "ExclamationMark", "Minus")) {
+        const operator = getCurrentToken(parser);
+        parser.position++
+        const right = parseUnaryExpression(utkrisht, parser);
+        return { type: "UnaryExpression", operator, right };
+    }
+
+    return parsePrimaryExpression(utkrisht, parser);
+}
+
+
+function parseMultiplicationAndDivisionExpression(utkrisht, parser) {
+    let expression = parseUnaryExpression(utkrisht, parser);
+
+    while (isCurrentTokenType(parser, "Asterisk", "Slash")) {
+        const operator = getCurrentToken(parser);
+        parser.position++;
+        const right = parseUnaryExpression(utkrisht, parser)
+        expression = { left: expression, operator, right }
+    }
+
+    return expression;
+}
+
+function parseAdditionAndSubstractionExpression(utkrisht, parser) {
+    let expression = parseMultiplicationAndDivisionExpression(utkrisht, parser);
+
+    while (isCurrentTokenType(parser, "Plus", "Minus")) {
+        const operator = getCurrentToken(parser);
+        parser.position++;
+        const right = parseMultiplicationAndDivisionExpression(utkrisht, parser);
+        expression = { left: expression, operator, right }
+    }
+
+    return expression;
+}
+
+
+function parseComparisonExpression(utkrisht, parser) {
+    let expression = parseAdditionAndSubstractionExpression(utkrisht, parser);
+
+    while (isCurrentTokenType(parser, "MoreThan", "LessThan", "ExclamationMarkMoreThan", "ExclamationMarkLessThan")) {
+        const operator = getCurrentToken(parser);
+        parser.position++;
+        const right = parseAdditionAndSubstractionExpression(utkrisht, parser);
+        expression = { left: expression, operator, right }
+    }
+
+    return expression;
+}
+
+function parseEqualityAndInequalityExpression(utkrisht, parser) {
+    let expression = parseComparisonExpression(utkrisht, parser);
+
+    while (isCurrentTokenType(parser, "Equal", "ExclamationMarkEqual")) {
+        const operator = getCurrentToken(parser);
+        parser.position++;
+        const right = parseComparisonExpression(utkrisht, parser);
+        expression = { left: expression, operator, right };
+    }
+    return expression;
+}
+
+function parseExpression(utkrisht, parser) {
+    return parseEqualityAndInequalityExpression(utkrisht, parser);
+}
+
+function parseExpressionStatement(utkrisht, parser) {
+    const expressionStatement = parseExpression(utkrisht, parser);
+    expectToken(utkrisht, parser, "NewLine", "Dedent", "EndOfFile");
+    ignoreToken(parser, "NewLine")
+    return expressionStatement;
+}
+
+
+function parseWhenStatement(utkrisht, parser) {
+
+}
+function parseLoopStatement(utkrisht, parser) {
+
+}
+function parseTryStatement(utkrisht, parser) {
+
+}
+function parseExitStatement(utkrisht, parser) {
+
+}
+function parseStopOrSkipStatement(utkrisht, parser) {
+
+}
+
+function parseVariableAssignmentStatement(utkrisht, parser) {
+
+}
+
+function parseVariableDeclaration(utkrisht, parser) {
+    const name = getCurrentToken(parser);
+
+    const parametersOrArguments = [];
+    while (isCurrentTokenType(parser, "Identifier")) {
+        const name = getCurrentToken(parser);
+        parser.position++
+
+
+    }
+}
+
+
+function parseStatement(utkrisht, parser) {
+    if (isCurrentTokenType(parser, "When")) {
+        return parseWhenStatement(utkrisht, parser);
+    }
+    else if (isCurrentTokenType(parser, "Loop")) {
+        return parseLoopStatement(utkrisht, parser);
+    }
+    else if (isCurrentTokenType(parser, "Try")) {
+        return parseTryStatement(utkrisht, parser);
+    }
+    else if (isCurrentTokenType(parser, "Exit")) {
+        return parseExitStatement(utkrisht, parser);
+    }
+    else if (isCurrentTokenType(parser, "Stop", "Skip")) {
+        return parseStopOrSkipStatement(utkrisht, parser);
+    }
+    else if (isCurrentTokenType(parser, "Identifier") && isVariableAssignment(parser)) {
+        return parseVariableAssignmentStatement(utkrisht, parser);
+    }
+    else {
+        if (isCurrentTokenType(parser, "Else")) {
+            throw error(utkrisht, "Can not use `else` statement without `when` statement", getCurrentToken(parser));
+        } else if (isCurrentTokenType(parser, "Fix")) {
+            throw error(utkrisht, "Can not use `fix` statement without `try` statement", getCurrentToken(parser));
+        } else if (isCurrentTokenType(parser, "With")) {
+            throw error(utkrisht, "Can not use `with` statement without `loop` statement", getCurrentToken(parser))
+        } else {
+            return parseExpressionStatement(utkrisht, parser);
+        }
+    }
+}
+
+
+
+
+
+function parseDeclaration(utkrisht, parser) {
+    try {
+        if (isCurrentTokenType(parser, "Identifier") && isVariableDeclaration(parser)) {
+            parseVariableDeclaration(utkrisht, parser);
+        } else {
+            return parseStatement(utkrisht, parser);
+        }
+    } catch (error) {
+        // We are only concerned about parser errors, not bugs in this file.
+        if (error instanceof ParseError) {
+            synchronise(parser);
+            return undefined;
+        }
+
+        // If it is a different error, let the developer handle it
+        throw error;
+    }
+}
+
+export function parse(utkrisht, parser) {
+    const statements = [];
+
+    while (!isAtEnd(parser)) {
+        statements.push(parseDeclaration(utkrisht, parser));
+    }
+
+    return statements;
+}
+
+
+

package/compiler/utkrisht.js

@@ -0,0 +1,53 @@
+import { readFileSync } from "node:fs";
+import { createLexer, lex } from "./lexer.js";
+import { createParser, parse } from "./parser.js";
+
+export function createUtkrisht() {
+    return {
+        hadError: false
+    };
+}
+
+
+function run(utkrisht, source) {
+    const lexer = createLexer(source);
+    const tokens = lex(utkrisht, lexer);
+
+    console.log(JSON.stringify(tokens, null, 4))
+    if (utkrisht.hadError) {
+        return;
+    }
+    const parser = createParser(tokens);
+    const statements = parse(utkrisht, parser);
+
+    console.log(JSON.stringify(statements, null, 4));
+}
+
+
+function runFile(path) {
+    let data;
+    try {
+        data = readFileSync(path, "utf8");
+    } catch (err) {
+        console.error("Error reading file: ", err.message);
+        process.exit(0);
+    }
+
+    const utkrisht = createUtkrisht();
+
+    run(utkrisht, data);
+}
+
+export function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length > 1) {
+        console.error("Usage node uki <input.uki>");
+        process.exit(0);
+    }
+
+    runFile(args[0]);
+}
+
+main();
+

package/extension/readme.md

@@ -0,0 +1,3 @@
+
+
+# Utkrisht

package/extension/utkrisht/.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+	// See https://go.microsoft.com/fwlink/?LinkId=733558
+	// for the documentation about the extensions.json format
+	"recommendations": [
+		"dbaeumer.vscode-eslint",
+		"ms-vscode.extension-test-runner"
+	]
+}

package/extension/utkrisht/.vscode/launch.json

@@ -0,0 +1,17 @@
+// A launch configuration that launches the extension inside a new window
+// Use IntelliSense to learn about possible attributes.
+// Hover to view descriptions of existing attributes.
+// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+{
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Run Extension",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}"
+			]
+		}
+	]
+}

package/extension/utkrisht/.vscode-test.mjs

@@ -0,0 +1,5 @@
+import { defineConfig } from '@vscode/test-cli';
+
+export default defineConfig({
+	files: 'test/**/*.test.js',
+});

package/extension/utkrisht/.vscodeignore

@@ -0,0 +1,10 @@
+.vscode/**
+.vscode-test/**
+test/**
+.gitignore
+.yarnrc
+vsc-extension-quickstart.md
+**/jsconfig.json
+**/*.map
+**/eslint.config.mjs
+**/.vscode-test.*

package/extension/utkrisht/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change Log
+
+All notable changes to the "utkrisht" extension will be documented in this file.
+
+Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
+
+## [Unreleased]
+
+- Initial release

package/extension/utkrisht/README.md

@@ -0,0 +1,65 @@
+# utkrisht README
+
+This is the README for your extension "utkrisht". After writing up a brief description, we recommend including the following sections.
+
+## Features
+
+Describe specific features of your extension including screenshots of your extension in action. Image paths are relative to this README file.
+
+For example if there is an image subfolder under your extension project workspace:
+
+\!\[feature X\]\(images/feature-x.png\)
+
+> Tip: Many popular extensions utilize animations. This is an excellent way to show off your extension! We recommend short, focused animations that are easy to follow.
+
+## Requirements
+
+If you have any requirements or dependencies, add a section describing those and how to install and configure them.
+
+## Extension Settings
+
+Include if your extension adds any VS Code settings through the `contributes.configuration` extension point.
+
+For example:
+
+This extension contributes the following settings:
+
+* `myExtension.enable`: Enable/disable this extension.
+* `myExtension.thing`: Set to `blah` to do something.
+
+## Known Issues
+
+Calling out known issues can help limit users opening duplicate issues against your extension.
+
+## Release Notes
+
+Users appreciate release notes as you update your extension.
+
+### 1.0.0
+
+Initial release of ...
+
+### 1.0.1
+
+Fixed issue #.
+
+### 1.1.0
+
+Added features X, Y, and Z.
+
+---
+
+## Working with Markdown
+
+You can author your README using Visual Studio Code.  Here are some useful editor keyboard shortcuts:
+
+* Split the editor (`Cmd+\` on macOS or `Ctrl+\` on Windows and Linux)
+* Toggle preview (`Shift+Cmd+V` on macOS or `Shift+Ctrl+V` on Windows and Linux)
+* Press `Ctrl+Space` (Windows, Linux, macOS) to see a list of Markdown snippets
+
+## For more information
+
+* [Visual Studio Code's Markdown Support](http://code.visualstudio.com/docs/languages/markdown)
+* [Markdown Syntax Reference](https://help.github.com/articles/markdown-basics/)
+
+**Enjoy!**

package/extension/utkrisht/eslint.config.mjs

@@ -0,0 +1,25 @@
+import globals from "globals";
+
+export default [{
+    files: ["**/*.js"],
+    languageOptions: {
+        globals: {
+            ...globals.commonjs,
+            ...globals.node,
+            ...globals.mocha,
+        },
+
+        ecmaVersion: 2022,
+        sourceType: "module",
+    },
+
+    rules: {
+        "no-const-assign": "warn",
+        "no-this-before-super": "warn",
+        "no-undef": "warn",
+        "no-unreachable": "warn",
+        "no-unused-vars": "warn",
+        "constructor-super": "warn",
+        "valid-typeof": "warn",
+    },
+}];

package/extension/utkrisht/jsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"module": "Node16",
+		"target": "ES2022",
+		"checkJs": false,  /* Typecheck .js files. */
+		"lib": [
+			"ES2022"
+		]
+	},
+	"exclude": [
+		"node_modules"
+	]
+}

package/extension/utkrisht/language-configuration.json

@@ -0,0 +1,62 @@
+{
+    "comments": {
+        "lineComment": "#",
+    },
+    "brackets": [
+        [
+            "[",
+            "]"
+        ],
+        [
+            "{",
+            "}"
+        ],
+        [
+            "(",
+            ")"
+        ]
+    ],
+    "autoClosingPairs": [
+        [
+            "(",
+            ")"
+        ],
+        [
+            "{",
+            "}"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        {
+            "open": "\"",
+            "close": "\"",
+            "notIn": ["string"]
+        }
+    ],
+    "surroundingPairs": [
+        [
+            "[",
+            "]"
+        ],
+        [
+            "(",
+            ")"
+        ],
+        [
+            "\"",
+            "\""
+        ],
+        [
+            "{", "}"
+        ]
+    ],
+    "folding": {
+        "offSide": true,
+        "markers": {
+            "start": "^\\s*#region",
+            "end": "^\\s*#endregion"
+        }
+    }
+}

package/extension/utkrisht/merge.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     width="24" height="24"
+     viewBox="0 -960 960 960"
+     fill="#e3e3e3">
+  <g transform="rotate(180 480 -480)">
+    <path d="m256-120-56-56 193-194q23-23 35-52t12-61v-204l-64 63-56-56 160-160 160 160-56 56-64-63v204q0 32 12 61t35 52l193 194-56 56-224-224-224 224Z"/>
+  </g>
+</svg>