pure-dango 1.8.0

package/src/index.ts

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+// pure-dango v0.9.1.
+// a programming language made for precision and myself
+
+
+// TODO: Document
+
+// note for myself: 
+// tokenizer: tokens 
+// parser: syntax errors 
+// compiler: bytecode converter interpreter: 
+// runtime errors
+
+
+process.title = "pure-dango";
+
+// imports
+import fs        from "fs";
+import path      from "path";
+import readline  from "readline";
+import {execSync} from "child_process";
+
+import {parser}                    from  "./core/parser/main";
+import {tokenizer}                 from  "./core/tokenizer/tokenizer";
+import {interpret, Scope, initGMP} from  "./core/interpreter";
+import {buildBytecode}             from  "./core/compiler";
+
+import * as utils from "./core/utils";
+const   
+{
+    run,
+    saveBytecode,
+    loadBytecode
+} = utils;
+
+// get all info
+const packageJson =
+{
+    name:        typeof PACKAGE_NAME        !== "undefined" ? PACKAGE_NAME        : "pure-dango",
+    version:     typeof PACKAGE_VERSION     !== "undefined" ? PACKAGE_VERSION     : "1.8.0",
+    description: typeof PACKAGE_DESCRIPTION !== "undefined" ? PACKAGE_DESCRIPTION : "A simple programming language built in JavaScript"
+};
+
+type ASTOutput =
+{
+    scopes    : Scope
+    stack     : (number | bigint | string | null | undefined)[];
+}
+
+function pause(code: number = 0)
+{
+    // creates a way to question the user
+    const rl = readline.createInterface(
+        {
+            input  : process.stdin,
+            output : process.stdout
+        }
+    );
+
+    // questions the user
+    rl.question(
+        "\nPress enter to exit...", () =>
+        {
+            rl.close();
+            process.exit(code);
+        }
+    );
+}
+
+process.on(
+    "warning", (warning) => 
+    {
+        if (warning.name === 'ExperimentalWarning' && warning.message.includes('Fetch API'))
+            return;
+        console.warn(warning);
+    }
+);
+
+(async function main()
+{
+    if (process.platform === "win32")
+    {
+        try 
+        { 
+            execSync("reg add HKCU\\Console /v VirtualTerminalLevel /t REG_DWORD /d 1 /f", {stdio: "ignore"}); 
+        }
+        catch {}
+    }   
+
+    process.on(
+        "uncaughtException", () =>
+        {
+            process.stdout.write("\x1B[?25h");
+            process.exit(1);
+        }
+    );
+    process.on("exit", () => process.stdout.write("\x1B[?25h"));
+    process.on(
+        "SIGINT", () => 
+        { 
+            process.stdout.write("\x1B[?25h"); 
+            process.exit(); 
+        }
+    );
+
+    let state : {time : number, position : number} = 
+    {
+        time     : 0,
+        position : 0
+    }
+
+    const args = process.argv.slice(2); 
+
+    let filename: string;
+    if (args[0] === "run") 
+        filename = args[1];
+    else if (args[0]) 
+        filename = args[0];
+    else
+    {
+        console.error("please provide a file to run (.pds)");
+        pause(1);
+        return;
+    }
+
+    if (!filename.endsWith(".pds")) 
+    {   
+        console.error(`file "${filename}" is not a (.pds) Pure Dango Script file`);
+        pause(1);
+        return;
+    }
+
+    const filePath: string = path.resolve(process.cwd(), filename);
+    if (!fs.existsSync(filePath))
+    {
+        console.error(`file not found: ${filename}`);
+        pause(1);
+        return;
+    }
+
+    // greeting (might change later)
+    console.log(`Welcome to ${packageJson.name} v${packageJson.version}`);
+    console.log(`${packageJson.description} \n`);
+
+    const cache = process.env.LOCALAPPDATA  // Windows
+           || process.env.XDG_CACHE_HOME    // Linux (proper)
+           || path.join(process.env.HOME || process.cwd(), ".cache"); // Linux fallback
+
+    const pureDangoDirectory : string = path.join(cache, "pure-dango"); // get the normal path
+    const cacheFolder        : string = path.join(pureDangoDirectory, ".pdbccache"); // if the filepath is "C:/user/Documents/pure-dango" it will be: "C:/user/Documents/pure-dango/.pdbccache"
+
+    if (!fs.existsSync(cacheFolder)) 
+        fs.mkdirSync(cacheFolder, {recursive: true}); // makes a file with the path of cacheFolder
+
+    try
+    {
+        let FILE = fs.readFileSync(filePath, "utf-8"); // Read the file given by the user
+        if (FILE.charCodeAt(0) === 0xFFFE || FILE.charCodeAt(0) === 0xFEFF)
+            FILE = Buffer.from(FILE, "binary").toString("utf16le");
+        FILE = FILE.replace(/\u0000/g, "");
+
+        const srcMTime =   fs.statSync(filePath).mtimeMs; 
+        
+        await initGMP();
+
+        let BYTECODE : Array<string | number> | null = loadBytecode(cacheFolder, filename);
+
+        if (!BYTECODE)
+        {
+            const TOKENS    : BaseToken[] =  await run(tokenizer, state, FILE);
+            const PARSED    : AST         =  await run(parser, state, TOKENS);
+            BYTECODE                      =  await run(buildBytecode, state, PARSED, filePath);
+            const OUTPUT : ASTOutput      =  await run(interpret, state, BYTECODE, path.dirname(path.resolve(filePath)), filePath);
+
+            saveBytecode(cacheFolder, BYTECODE as Array<string | number>, filename, srcMTime);
+        }
+
+        else 
+            await run(interpret, state, BYTECODE, path.dirname(path.resolve(filePath)), filePath);
+
+        console.log(`\nPure dango program exited after: ${state.time.toFixed(3)} milliseconds...`);
+    }
+
+    catch (error : unknown)
+    {
+        console.error(`\n${(error as Error).message}`);
+        console.log(`Pure dango program exited after: ${state.time.toFixed(3)} milliseconds...`);
+    }
+})()

package/src/runtime/errors.ts

@@ -0,0 +1,239 @@
+export class GeneralError extends Error
+{
+    constructor(name : string, message : string)
+    {
+        super(`[ERROR] ${name}:\n${message}`);
+        this.name = "";
+    }
+}
+
+// singular tokenizer error
+export class Tokenizer extends GeneralError
+{
+    constructor(message : string, row : number, column : number)
+    {
+        super(`Tokenizer [${row}:${column}]`, message);
+    }
+}
+
+// runtime errors
+class ConstantAssignmentOperator extends GeneralError
+{
+    constructor(variableName : string)
+    {
+        super(`ConstantAssignmentOperator`, `assignment to a constant "${variableName}"`);
+    }
+}
+
+class FunctionError extends GeneralError
+{
+    constructor(functionName : string) 
+    {
+        super("FunctionError", `function "${functionName}" does not exist`);
+    }
+}
+
+class StackError extends GeneralError
+{
+    constructor()
+    {
+        super("StackError", `pop on empty stack`);
+    }
+}
+
+class MissingStackTokenError extends GeneralError
+{
+    constructor(expected : string | number)
+    {
+        super("MissingTokenError", `expected a value after "${expected}"`);
+    }
+}
+
+class BreakError extends GeneralError
+{
+    constructor()
+    {
+        super("BreakError", `break statement outside of loop`);
+    }
+}
+
+class ContinueError extends GeneralError
+{
+    constructor()
+    {
+        super("ContinueError", `continue statement outside of loop`);
+    }
+}
+
+class DivisionByZero extends GeneralError
+{
+    constructor(left : bigint | any, right : bigint | any)
+    {
+        super("DivisionByZero", `operands must not divide by 0, got "${left}/${right}"`);
+    }
+}
+
+class InternalError extends GeneralError
+{
+    constructor(message: string)
+    {
+        super("InternalError", message);
+    }
+}
+
+class MethodError extends GeneralError
+{
+    constructor(methodName: string)
+    {
+        super("MethodError", `method "${methodName}" does not exist`);
+    }
+}
+
+class PropertyError extends GeneralError
+{
+    constructor(methodName: string)
+    {
+        super("PropertyError", `property "${methodName}" does not exist`);
+    }
+}
+
+class ClassError extends GeneralError
+{
+    constructor(className: string)
+    {
+        super("ClassError", `"${className}" is not a class`);
+    }
+}
+
+export const runtimeErrors =
+{
+    FunctionError,
+    ConstantAssignmentOperator,
+    BreakError,
+    ContinueError,
+    StackError,
+    MissingStackTokenError,
+    DivisionByZero,
+    InternalError,
+    MethodError,
+    PropertyError,
+    ClassError
+}
+
+// parsing errors
+class SyntaxError extends GeneralError
+{
+    constructor(message : string, row : number, column : number)
+    {
+        super("SyntaxError", `${message} at line ${row}:${column}`);
+    }
+}
+
+class FunctionCallError extends SyntaxError 
+{
+    constructor(message : string, row : number, column : number) 
+    {
+        super(message, row, column);
+    }
+}
+
+class ChainedFunctionCallError extends SyntaxError
+{
+    constructor (name : string, row : number, column : number)
+    {
+        super(`chained function calls are not allowed: "${name}(...)()"`, row, column);
+    }
+}
+
+class ChainedIncDecError extends SyntaxError
+{
+    constructor (row : number, column : number)
+    {
+        super(`chained increment/decrement operators are not allowed`, row, column);
+    }
+}
+
+class InvalidPostfixError extends SyntaxError
+{
+    constructor (operator : string, type : string, value : any, row : number, column : number)
+    {
+        super(`cannot apply "${operator}" to ${type.toLocaleLowerCase()} "${value}"`, row, column);
+    }
+}
+
+class AssignmentError extends SyntaxError
+{
+    constructor(operator : any, row : number, column : number)
+    {
+        super(`left side of "${operator}" must be a variable`, row, column);
+    }
+}
+
+class UnexpectedTokenError extends SyntaxError
+{
+    constructor(tokenValue : any, row : number, column : number)
+    {
+        super(`unexpected token "${tokenValue}"`, row, column);
+    }
+}
+
+class MissingTokenError extends SyntaxError
+{
+    constructor(expected : string, row : number, column : number)
+    {
+        super(`expected "${expected}"`, row, column);
+    }
+}
+
+class MissingRightSide extends SyntaxError
+{
+    constructor(after : any, row : number, column : number)
+    {
+        super(`rxpected an expression or value after "${after}"`, row, column);
+    }
+}
+
+class UnaryOperatorError extends SyntaxError
+{
+    constructor(value : any, row : number, column : number)
+    {
+        super(`unknown fix type for unary operator "${value}"`, row, column);
+    }
+}
+
+export const parseErrors = 
+{
+    FunctionCallError,
+    ChainedFunctionCallError,
+    ChainedIncDecError,
+    AssignmentError,
+    UnexpectedTokenError,
+    MissingTokenError,
+    InvalidPostfixError,
+    MissingRightSide,
+    UnaryOperatorError
+}
+
+// utils errors
+
+class NegativeExponentError extends GeneralError
+{
+    constructor(exponent : number | bigint | any)
+    {
+        super("NegativeExponentError", `exponent "${exponent}" must be positive when raising BigInt`);
+    }
+}
+
+class FunctionArgumentError extends GeneralError
+{
+    constructor(functionName : string, maxLength : number, plural : string)
+    {
+        super("FunctionArgumentError", `function "${functionName}" only takes ${maxLength} ${plural}`);
+    }
+}
+
+export const utilsErrors = 
+{
+    NegativeExponentError,
+    FunctionArgumentError
+}

package/src/runtime/globals.ts

@@ -0,0 +1,11 @@
+export const constants = Object.create(null);
+
+constants["undefined"] = true;
+constants["null"]      = true;
+constants["true"]      = true;
+constants["false"]     = true;
+
+export function isConstant(name: string)
+{
+    return constants[name] === true;
+}

package/src/runtime/libs/ai.pds

@@ -0,0 +1,56 @@
+import internal "types.pds";
+
+class AI
+{
+    constructor(apiKey, model, url)
+    {
+        this.apiKey = apiKey;
+        this.model  = model;
+        this.url    = url
+        this.conversationHistory = [];
+    }
+
+    ask(prompt)
+    {
+        push(this.conversationHistory, {role: "user", content: prompt});
+
+        new requestBody = 
+        {
+            model: this.model,
+            max_completion_tokens: 1024,
+            messages: this.conversationHistory
+        };
+
+        new headers = 
+        {
+            headers: 
+            {
+                "Content-Type" : "application/json",
+                "Authorization": concat("Bearer ", this.apiKey)
+            }
+        };
+
+        new response = 
+            http_post(
+                this.url,
+                requestBody,
+                headers
+            );
+
+        new parsed = tobj(response);
+        new assistantMessage = parsed.choices[0].message.content;
+
+        push(this.conversationHistory, {role: "assistant", content: assistantMessage});
+        return assistantMessage;
+    }
+
+    clearHistory()
+    {
+        this.conversationHistory = [];
+    }
+
+    setSystemPrompt(prompt)
+    {
+        this.systemPrompt = prompt;
+    }
+}

package/src/runtime/libs/errors.pds

@@ -0,0 +1,74 @@
+# all errors.
+class Error
+{
+    constructor(x)
+    {
+        if (typeof(x) != "string")
+            throwerror("Error", concat('Parameter "__INIT__" of class "Error" must be type String. But got "', x, '"'));
+            
+        this.__INIT__ = x;
+        this.name = "Error";
+    }
+
+    throw(message)
+    {
+        if (message)
+            throwerror(this.name, message);
+        else
+            throwerror(this.name, this.__INIT__);
+    }
+}
+
+class TypeError extends Error
+{
+    constructor(x)
+    {
+        super(x);
+        this.name = "TypeError";
+    }
+}
+
+class ValueError extends Error
+{
+    constructor(x)
+    {
+        super(x);
+        this.name = "ValueError";
+    }
+}
+
+class IndexError extends Error
+{
+    constructor(x)
+    {
+        super(x);
+        this.name = "IndexError";
+    }
+}
+
+class NotImplementedError extends Error
+{
+    constructor(x)
+    {
+        super(x);
+        this.name = "NotImplementedError";
+    }
+}
+
+class RangeError extends Error
+{
+    constructor(x)
+    {
+        super(x);
+        this.name = "RangeError";
+    }
+}
+
+class InternalError extends Error
+{
+    constructor(x)
+    {
+        super(x);
+        this.name = "InternalError";
+    }
+}

package/src/runtime/libs/gambling.pds

@@ -0,0 +1,93 @@
+class gambling
+{
+    constructor(...args : Tuple<string, float>)
+    {
+        this.__INIT__ = {};
+
+        for (new pair of args)
+            this.addItem(pair[0], pair[1]);
+    }
+
+    addItem(name : string, rarity : float) : void
+        this.__INIT__[name] = rarity;
+
+    removeItem(name : string) : void
+        this.__INIT__[name] = null;
+
+    editItem(name : string, newLuck : float) : void
+        this.__INIT__[name] = newLuck;
+
+    roll() : string
+    {
+        new items = [];
+        new weights = [];
+
+        new itemKeys = keys(this.__INIT__);
+        for (new name of itemKeys)
+        {
+            new luck = this.__INIT__[name];
+            if (luck != null && luck != undefined)
+            {
+                push(items, name);
+                push(weights, luck);
+            }
+        }
+
+        if (len(items) == 0)
+            return null;
+
+        new total = 0;
+        for (new weight of weights)
+            total += weight;
+
+        new roll = random(0, total);
+
+        new cumulative = 0;
+        new i = 0;
+        for (new weight of weights)
+        {
+            cumulative += weight;
+            if (roll <= cumulative)
+                return items[i];
+
+            i += 1;
+        }
+
+        return items[len(items) - 1];
+    }
+}
+
+new a = inst gambling( 
+    ["stone", 2], 
+    ["rock", 1.5],
+    ["bread", 1],
+    ["water", 0.8],
+    
+    ["coral, the emperor", 0.5], 
+    ["vile, the soldier of death", 0.35],
+    ["frant, the fallen emperor", 0.3],
+    
+    ["tesla, creator of AC current", 0.3],
+    ["einstein, sage of theories", 0.2], 
+    ["newton, holder of the apple", 0.1],
+
+    ["cass, holder of money", 0.08], # on a side note he killed frant, not like it's better than money
+
+    ["kilnit, emperor of emperors", 0.07],   # proved his strength by defeating all emeprors. This guy is SO arrogant though.
+    ["cornelius, god of emperors", 0.01],    # protects emperors as an emperor god, even the emperor of emperors bow down to him. Completely immortal. 
+    ["forthhalt, death of emperors", 0.008], # DESPISES emperors. This guy HATES cornelius and unfortunately is immortal like cornelius
+);
+
+new i = 0;
+new results = {};
+
+while (i < 1000)
+{
+    new result = a.roll();
+    if (results[result] == undefined)
+        results[result] = 0;
+    results[result] += 1;
+    i += 1;
+}
+
+print(results);