affinirum 1.2.1 → 1.2.3

package/README.md

@@ -22,13 +22,15 @@ Target: ES2022 [browser+NodeJS][ESM+CJS].
 
 ## Specifications
 
-Script can contain multiple semicolon-separated expressions, and blocks of statements.
-The value of a block is determined by the value of the last expression.
+A script may contain multiple expressions separated by semicolons, as well as blocks of statements.
+The value of a block is defined by the value of its last expression.
 - Scientific notation is supported for floating point numbers, like *0.1281e+2*.
 - ISO Timestamps prefixed with **@**, like *@2025-05-11T19:09:21.320Z*.
-- Hexadecimal buffer values are enclosed in backtick (**\`**) quotes, like *\`10ab0901\`*.
-- String literals are enclosed in single (**'**), or double (**"**) quotes, like *'string value1'*, or *"string value2"*.
+- Hexadecimal buffer values are enclosed in backticks (**\`**), like *\`10ab0901\`*.
+- String literals may be enclosed in single (**'**), or double (**"**) quotes, like *'string value1'*, or *"string value2"*.
+- Line comments begin with a double slash (**//**), while block comments are enclosed in triple slashes (**///**).
 
+### Arrays
 Array is an ordered sequence of values of any type.
 It is defined by comma-separated values enclosed in brackets (**[]**),
  like  *[0,1,2]*, *["a","b","c"]*.
@@ -39,6 +41,7 @@ Array elements can be accessed using the access operator (**.**),
 
 Easy way to check if array contains an index is to use presence operator (**?**), like *theArray?50*.
 
+### Objects
 Object is a container of named values of any type.
 It is defined by comma-separated key-value pair enclosed in brackets (**[]**) where key is separated from value by colon (**:**),
  like *["key1":100, "key2":"abc"]*, *["a":0,"b":"str":"c":valueVar]*.
@@ -50,13 +53,14 @@ Object properties can be accessed using the access operator (**.**) with a strin
 
 Easy way to check if object contains a key is to use presence operator (**?**), like *theObject?myKey*.
 
+### Functions
 A function is a callable code unit that produces a value.
 The set of built-in functions can be extended through configuration entries.
 Additionally, subroutines (functions defined in code) can be created.
 
-Valid variable and function names must start with a letter or underscore (**\_**)
- and can be followed by any combination of alphanumeric characters or underscores,
- like *x*, *\_a1*, *abc25*.
+Valid variable and function names must start with a letter, number sign (**\#**), dollar sign (**\$**), or underscore (**\_**)
+ and can be followed by any combination of alphanumeric characters, number signs, dollar signs, or underscores,
+ like *x*, *\_a1$*, *abc25*.
 
 Whitespace characters are ignored.
 
@@ -118,7 +122,7 @@ Unknown or variant type is declared as **??**.
 - Arithmetic division assignment: **/=**
 - Arithmetic remainder assignment: **%=**
 
-### Constants
+### Predefined Constants
 
 #### Boolean
 - **boolean Boolean.Or(values:array...)** — Boolean disjunction
@@ -186,7 +190,7 @@ Unknown or variant type is declared as **??**.
 - **void | boolean | float | string | array | object JSON.Parse(value: string)** — Parse JSON-formatted string
 
 
-### Functions
+### Predefined Functions
 
 #### General Functions
 - **?? ??.Coalesce(otherwise: ??)** — Null coalescence

package/dst/Affinirum.d.ts

@@ -54,7 +54,7 @@ export declare class Affinirum {
         @returns Calculated value.
     */
     evaluate(values?: Record<string, Value>): Value;
-    protected _block(state: ParserState, scope: StaticScope): Node;
+    protected _list(state: ParserState, scope: StaticScope): Node;
     protected _unit(state: ParserState, scope: StaticScope): Node;
     protected _coalescence(state: ParserState, scope: StaticScope): Node;
     protected _disjunction(state: ParserState, scope: StaticScope): Node;
@@ -70,6 +70,5 @@ export declare class Affinirum {
     protected _function(state: ParserState, scope: StaticScope): Node;
     protected _loop(state: ParserState, scope: StaticScope): LoopNode;
     protected _switch(state: ParserState, scope: StaticScope): SwitchNode;
-    protected _call(frame: ParserFrame, func: Constant, subnodes: Node[]): Node;
     protected _type(state: ParserState, scope: StaticScope): Type;
 }

package/dst/Affinirum.js

@@ -12,13 +12,15 @@ import { Functions } from "./Functions.js";
 import { ArrayNode } from "./node/ArrayNode.js";
 import { BlockNode } from "./node/BlockNode.js";
 import { ConstantNode } from "./node/ConstantNode.js";
-import { CallNode } from "./node/CallNode.js";
+import { FunctionNode } from "./node/FunctionNode.js";
+import { JumpNode } from "./node/JumpNode.js";
 import { LoopNode } from "./node/LoopNode.js";
 import { ObjectNode } from "./node/ObjectNode.js";
 import { SwitchNode } from "./node/SwitchNode.js";
 import { VariableNode } from "./node/VariableNode.js";
 import { ParserState } from "./ParserState.js";
 import { StaticScope } from "./StaticScope.js";
+import { JumpException } from "./JumpException.js";
 export class Affinirum {
     static keywords = [...Keywords, ...Constants.map((c) => c[0])];
     _script;
@@ -45,8 +47,8 @@ export class Affinirum {
             }
         }
         const state = new ParserState(this._script);
-        this._root = this._block(state.next(), this._scope);
-        if (!state.isVoid) {
+        this._root = this._list(state.next(), this._scope);
+        if (!state.isEmpty) {
             state.throwError("unexpected expression token or expression end");
         }
         this._root = this._root.compile(config?.type ?? Type.Unknown);
@@ -100,15 +102,34 @@ export class Affinirum {
             }
             variable.value = value;
         }
-        return this._root.evaluate();
+        try {
+            return this._root.evaluate();
+        }
+        catch (e) {
+            if (e instanceof JumpException) {
+                if (e.jump === "exit") {
+                    return e.value;
+                }
+                else {
+                    throw this._root.throwError(`unexpected ${e.jump} jump`);
+                }
+            }
+            throw e;
+        }
     }
-    _block(state, scope) {
+    _list(state, scope) {
         const frame = state.starts();
-        const nodes = [this._unit(state, scope)];
-        while (state.isSemicolon) {
-            nodes.push(this._unit(state.next(), scope));
+        const subnodes = [];
+        while (!state.isEmpty) {
+            subnodes.push(this._unit(state, scope));
+            if (!state.isSemicolon) {
+                break;
+            }
+            else {
+                state.next();
+            }
         }
-        return new BlockNode(frame.ends(state), nodes);
+        return new BlockNode(frame.ends(state), subnodes);
     }
     _unit(state, scope) {
         return this._coalescence(state, scope);
@@ -116,21 +137,24 @@ export class Affinirum {
     _coalescence(state, scope) {
         let node = this._disjunction(state, scope);
         while (state.operator === funcCoalesce) {
-            node = this._call(state.starts(), state.operator, [node, this._disjunction(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._disjunction(state.next(), scope)]);
         }
         return node;
     }
     _disjunction(state, scope) {
         let node = this._conjunction(state, scope);
         while (state.operator === funcOr) {
-            node = this._call(state.starts(), state.operator, [node, this._conjunction(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._conjunction(state.next(), scope)]);
         }
         return node;
     }
     _conjunction(state, scope) {
         let node = this._negation(state, scope);
         while (state.operator === funcAnd) {
-            node = this._call(state.starts(), state.operator, [node, this._negation(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._negation(state.next(), scope)]);
         }
         return node;
     }
@@ -144,7 +168,8 @@ export class Affinirum {
         }
         let node = this._comparison(state, scope);
         if (negate) {
-            node = this._call(frame, funcNot, [node]);
+            const fnode = new ConstantNode(frame, funcNot);
+            node = new FunctionNode(frame, fnode, [node]);
         }
         return node;
     }
@@ -153,21 +178,24 @@ export class Affinirum {
         while (state.operator === funcGreaterThan || state.operator === funcLessThan
             || state.operator === funcGreaterOrEqual || state.operator === funcLessOrEqual
             || state.operator === funcEqual || state.operator === funcNotEqual) {
-            node = this._call(state.starts(), state.operator, [node, this._aggregate(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._aggregate(state.next(), scope)]);
         }
         return node;
     }
     _aggregate(state, scope) {
         let node = this._product(state, scope);
         while (state.operator === funcAdd || state.operator === funcSubtract) {
-            node = this._call(state.starts(), state.operator, [node, this._product(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._product(state.next(), scope)]);
         }
         return node;
     }
     _product(state, scope) {
         let node = this._signum(state, scope);
         while (state.operator === funcMultiply || state.operator === funcDivide || state.operator === funcRemainder) {
-            node = this._call(state.starts(), state.operator, [node, this._signum(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._signum(state.next(), scope)]);
         }
         return node;
     }
@@ -183,14 +211,16 @@ export class Affinirum {
         }
         let node = this._factor(state, scope);
         if (negate) {
-            node = this._call(frame.ends(state), funcNegate, [node]);
+            const fnode = new ConstantNode(frame, funcNegate);
+            node = new FunctionNode(frame, fnode, [node]);
         }
         return node;
     }
     _factor(state, scope) {
         let node = this._accessor(state, scope);
         while (state.operator === funcPower) {
-            node = this._call(state.starts(), state.operator, [node, this._accessor(state.next(), scope)]);
+            const fnode = new ConstantNode(state, state.operator);
+            node = new FunctionNode(state, fnode, [node, this._accessor(state.next(), scope)]);
         }
         return node;
     }
@@ -201,11 +231,11 @@ export class Affinirum {
             if (state.isDot || state.isQuestion) {
                 const operator = state.isDot ? funcAt : funcHas;
                 if (state.next().isLiteral && (typeof state.literal.value === "string" || typeof state.literal.value === "bigint")) {
-                    node = this._call(frame.ends(state), operator, [node, new ConstantNode(state, new Constant(state.literal.value))]);
+                    const fnode = new ConstantNode(frame.ends(state), operator);
+                    node = new FunctionNode(frame, fnode, [node, new ConstantNode(state, new Constant(state.literal.value))]);
                     state.next();
                 }
                 else if (state.isToken) {
-                    frame.ends(state);
                     const func = this._functions.get(state.token);
                     if (func) {
                         if (state.next().isParenthesesOpen) {
@@ -216,15 +246,18 @@ export class Affinirum {
                                     break;
                                 }
                             }
-                            node = this._call(frame.ends(state), func, subnodes);
+                            const fnode = new ConstantNode(frame.ends(state), func);
+                            node = new FunctionNode(frame, fnode, subnodes);
                             state.closeParentheses().next();
                         }
                         else {
-                            node = this._call(frame, func, [node]);
+                            const fnode = new ConstantNode(frame.ends(state), func);
+                            node = new FunctionNode(frame, fnode, [node]);
                         }
                     }
                     else {
-                        node = this._call(frame, operator, [node, new ConstantNode(state, new Constant(state.token))]);
+                        const fnode = new ConstantNode(frame.ends(), operator);
+                        node = new FunctionNode(frame, fnode, [node, new ConstantNode(state, new Constant(state.token))]);
                         state.next();
                     }
                 }
@@ -240,11 +273,12 @@ export class Affinirum {
                         break;
                     }
                 }
-                node = new CallNode(frame.ends(state), node, subnodes);
+                node = new FunctionNode(frame.ends(state), node, subnodes);
                 state.closeParentheses().next();
             }
             else if (state.isBracketsOpen) {
-                node = this._call(frame, funcAt, [node, this._unit(state.next(), scope)]);
+                const fnode = new ConstantNode(frame, funcAt);
+                node = new FunctionNode(frame, fnode, [node, this._unit(state.next(), scope)]);
                 state.closeBrackets().next();
             }
         }
@@ -296,19 +330,29 @@ export class Affinirum {
                 }
                 if (state.assignment.operator) {
                     const operator = state.assignment.operator;
-                    const subnodes = [new VariableNode(frame, variable), this._unit(state.next(), scope)];
-                    return new VariableNode(frame, variable, this._call(frame, operator, subnodes));
+                    const fnode = new ConstantNode(frame, operator);
+                    const subnode = new FunctionNode(frame, fnode, [new VariableNode(frame, variable), this._unit(state.next(), scope)]);
+                    return new VariableNode(frame, variable, subnode);
                 }
                 else {
-                    return new VariableNode(frame, variable, this._unit(state.next(), scope));
+                    const subnode = this._unit(state.next(), scope);
+                    return new VariableNode(frame, variable, subnode);
                 }
             }
             return new VariableNode(frame, variable);
         }
         else if (state.isBracesOpen) {
-            const node = this._block(state.next(), scope);
-            state.closeBraces().next();
-            return node;
+            const frame = state.starts();
+            const subnodes = [];
+            while (!state.next().isBracesClose) {
+                subnodes.push(this._unit(state, scope));
+                if (!state.isSemicolon) {
+                    break;
+                }
+            }
+            frame.ends(state);
+            state.next();
+            return new BlockNode(frame, subnodes);
         }
         else if (state.isBracesClose) {
             state.throwError("unexpected closing braces");
@@ -344,7 +388,7 @@ export class Affinirum {
                 }
             }
             frame.ends(state);
-            state.closeBrackets().next();
+            state.next();
             if (colon) {
                 return new ObjectNode(frame, subnodes.map(([k, v]) => [typeof k === "number" ? new ConstantNode(v, new Constant(String(k))) : k, v]));
             }
@@ -353,8 +397,8 @@ export class Affinirum {
         else if (state.isBracketsClose) {
             state.throwError("unexpected closing brackets");
         }
-        else if (state.isVariable || state.isValue) {
-            const assignable = state.isVariable;
+        else if (state.isVar || state.isVal) {
+            const assignable = state.isVar;
             if (!state.next().isToken) {
                 state.throwError("missing variable name");
             }
@@ -380,13 +424,29 @@ export class Affinirum {
         else if (state.isTilda) {
             return this._function(state, scope);
         }
+        else if (state.isIf) {
+            return this._switch(state, scope);
+        }
         else if (state.isWhile) {
             return this._loop(state, scope);
         }
-        else if (state.isIf) {
-            return this._switch(state, scope);
+        else if (state.isExit) {
+            return new JumpNode(state, "exit", this._unit(state.next(), scope));
+        }
+        else if (state.isReturn) {
+            return new JumpNode(state, "return", this._unit(state.next(), scope));
         }
-        else if (state.isVoid) {
+        else if (state.isStop) {
+            const node = new JumpNode(state, "stop");
+            state.next();
+            return node;
+        }
+        else if (state.isNext) {
+            const node = new JumpNode(state, "next");
+            state.next();
+            return node;
+        }
+        else if (state.isEmpty) {
             state.throwError("unexpected end of expression");
         }
         state.throwError("unexpected expression token");
@@ -430,45 +490,29 @@ export class Affinirum {
         state.closeParentheses();
         frame.ends(state);
         const args = Array.from(variables.values());
-        state.next().openBraces().next();
-        const subnode = this._block(state, scope.subscope(variables));
-        state.closeBraces().next();
-        const value = (...values) => {
+        const subnode = this._unit(state.next(), scope.subscope(variables));
+        const func = (...values) => {
             args.forEach((arg, ix) => arg.value = values[ix]);
             return subnode.evaluate();
         };
-        const constant = new Constant(value, Type.functionType(retType, args.map((v) => v.type), variadic));
+        const constant = new Constant(func, Type.functionType(retType, args.map((v) => v.type), variadic));
         return new ConstantNode(frame, constant, subnode);
     }
     _loop(state, scope) {
         const frame = state.starts();
         const cnode = this._unit(state.next(), scope);
         frame.ends(state);
-        state.openBraces().next();
-        const subnode = this._block(state, scope);
-        state.closeBraces().next();
-        return new LoopNode(frame, cnode, subnode);
+        return new LoopNode(frame, cnode, this._unit(state, scope));
     }
     _switch(state, scope) {
         const frame = state.starts();
         const cnode = this._unit(state.next(), scope);
         frame.ends(state);
-        const subnodes = [];
-        state.openBraces().next();
-        subnodes.push(this._block(state, scope));
-        state.closeBraces().next();
-        if (state.isElse) {
-            state.next().openBraces().next();
-            subnodes.push(this._block(state, scope));
-            state.closeBraces().next();
-        }
-        else {
-            subnodes.push(new ConstantNode(state.starts(), Constant.Null));
-        }
-        return new SwitchNode(frame, cnode, subnodes);
-    }
-    _call(frame, func, subnodes) {
-        return new CallNode(frame, new ConstantNode(frame, func), subnodes);
+        const cthen = this._unit(state, scope);
+        const celse = state.isElse
+            ? this._unit(state.next(), scope)
+            : new ConstantNode(state.starts(), Constant.Null);
+        return new SwitchNode(frame, cnode, [cthen, celse]);
     }
     _type(state, scope) {
         if (state.isType) {

package/dst/Jump.d.ts

@@ -0,0 +1 @@
+export type Jump = "exit" | "return" | "stop" | "next";

package/dst/Jump.js

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

package/dst/JumpException.d.ts

@@ -0,0 +1,9 @@
+import { Jump } from "./Jump.js";
+import { Value } from "./Value.js";
+export declare class JumpException {
+    private readonly _jump;
+    private readonly _value?;
+    constructor(_jump: Jump, _value?: Value);
+    get jump(): Jump;
+    get value(): Value;
+}

package/dst/JumpException.js

@@ -0,0 +1,14 @@
+export class JumpException {
+    _jump;
+    _value;
+    constructor(_jump, _value) {
+        this._jump = _jump;
+        this._value = _value;
+    }
+    get jump() {
+        return this._jump;
+    }
+    get value() {
+        return this._value;
+    }
+}

package/dst/Keywords.js

@@ -10,8 +10,8 @@ export const Keywords = [
     "array",
     "object",
     "function",
-    "variable", "var",
-    "constant", "const",
-    "while",
+    "var",
+    "val",
     "if", "else",
+    "while", "stop", "next",
 ];

package/dst/Node.d.ts

@@ -1,6 +1,6 @@
 import { ParserFrame } from "./ParserFrame.js";
-import { Value } from "./Value.js";
 import { Type } from "./Type.js";
+import { Value } from "./Value.js";
 export declare abstract class Node extends ParserFrame {
     constructor(frame: ParserFrame);
     abstract type: Type;

package/dst/ParserState.d.ts

@@ -34,14 +34,18 @@ export declare class ParserState extends ParserFrame {
     get isComma(): boolean;
     get isDot(): boolean;
     get isQuestion(): boolean;
-    get isTilda(): boolean;
     get isEllipsis(): boolean;
-    get isVariable(): boolean;
-    get isValue(): boolean;
-    get isWhile(): boolean;
+    get isTilda(): boolean;
+    get isVar(): boolean;
+    get isVal(): boolean;
     get isIf(): boolean;
     get isElse(): boolean;
-    get isVoid(): boolean;
+    get isWhile(): boolean;
+    get isExit(): boolean;
+    get isReturn(): boolean;
+    get isStop(): boolean;
+    get isNext(): boolean;
+    get isEmpty(): boolean;
     openParentheses(): this;
     closeParentheses(): this;
     openBrackets(): this;