@woosh/meep-engine 2.49.4 → 2.49.7

package/src/core/parser/simple/readLiteralToken.js

@@ -0,0 +1,96 @@
+import { skipWhitespace } from "./skipWhitespace.js";
+import Token from "./Token.js";
+import DataType from "./DataType.js";
+import ParserError from "./ParserError.js";
+import { readBooleanToken } from "./readBooleanToken.js";
+import { readStringToken } from "./readStringToken.js";
+import { readNumberToken } from "./readNumberToken.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @return {Token}
+ */
+function readArrayLiteral(text, cursor, length) {
+    let i = cursor;
+
+    const firstChar = text.charAt(i);
+    if (firstChar !== '[') {
+        throw new ParserError(cursor, `expected array start: '[', got '${firstChar}' instead`, text);
+    }
+
+    i++;
+
+    const values = [];
+    while (i < length) {
+        i = skipWhitespace(text, i, length);
+
+        const token = readLiteralToken(text, i, length);
+
+        i = token.end;
+
+        values.push(token);
+
+        //try find separator
+        i = skipWhitespace(text, i, length);
+        if (i < length) {
+            const char = text.charAt(i);
+            if (char === ',') {
+                //separator
+                i++;
+            } else if (char === ']') {
+                //end of sequence
+                i++;
+                break;
+            } else {
+                //unexpected input
+                throw new ParserError(i, `Unexpected input '${char}', expected either separator ',' or end of sequence ']'`, text);
+            }
+        } else {
+            throw new ParserError(i, `Unterminated array literal`, text);
+        }
+    }
+
+    return new Token(values, cursor, i, 'array', DataType.Array);
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+function readLiteralToken(text, cursor, length) {
+    const firstChar = text.charAt(cursor);
+
+    switch (firstChar) {
+        case 't':
+        case 'f':
+            return readBooleanToken(text, cursor, length);
+        case '\"':
+        case "\'":
+            return readStringToken(text, cursor, length);
+        case '-':
+        case '+':
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            return readNumberToken(text, cursor, length);
+        case '[':
+            return readArrayLiteral(text, cursor, length);
+        default:
+            throw new ParserError(cursor, "Expected literal start, but found '" + firstChar + "'", text);
+    }
+}
+
+export { readLiteralToken };

package/src/core/parser/simple/readNumberToken.js

@@ -0,0 +1,73 @@
+import { skipWhitespace } from "./skipWhitespace.js";
+import { readHexToken } from "./readHexToken.js";
+import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readNumberToken(text, cursor, length) {
+    let i = cursor;
+
+    //read optional sign
+    function readSign(text) {
+        let sign = 1;
+        const firstChar = text.charAt(i);
+        if (firstChar === '-') {
+            sign = -1;
+        } else if (firstChar === '+') {
+            sign = 1;
+        } else {
+            return 1;
+        }
+
+        i = skipWhitespace(text, i + 1, length);
+
+        return sign;
+    }
+
+    const sign = readSign(text);
+
+    let value;
+
+    if (text.charAt(i) === '0' && (text.charAt(i + 1) === 'x' || text.charAt(i + 1) === 'X')) {
+        // hex number
+        const token = readHexToken(text, i, length);
+
+        i = token.end;
+
+        value = token.value;
+
+    } else {
+
+        const wholePart = readUnsignedIntegerToken(text, i, length);
+
+        i = wholePart.end;
+
+        value = wholePart.value;
+
+        if (i < length) {
+            const dot = text.charAt(i);
+            if (dot === '.') {
+                i++;
+                const fraction = readUnsignedIntegerToken(text, i, length);
+
+                const digits = (fraction.end - fraction.start);
+
+                value += fraction.value / Math.pow(10, digits);
+
+                i = fraction.end;
+            }
+        }
+    }
+
+    value *= sign;
+
+    return new Token(value, cursor, i, TokenType.LiteralNumber, DataType.Number);
+}

package/src/core/parser/simple/readNumberToken.spec.js

@@ -0,0 +1,17 @@
+import { readNumberToken } from "./readNumberToken.js";
+
+test("hex", () => {
+    expect(readNumberToken("0x3", 0, 3).value).toBe(3);
+});
+
+test("signed integer", () => {
+    expect(readNumberToken("+3", 0, 2).value).toBe(3);
+    expect(readNumberToken("3", 0, 1).value).toBe(3);
+    expect(readNumberToken("-7", 0, 2).value).toBe(-7);
+});
+
+test("decimal", () => {
+    expect(readNumberToken("1.0", 0, 3).value).toBe(1);
+    expect(readNumberToken("0.1", 0, 3).value).toBe(0.1);
+    expect(readNumberToken("-0.830", 0, 6).value).toBe(-0.830);
+});

package/src/core/parser/simple/readReferenceToken.js

@@ -0,0 +1,48 @@
+import DataType from "./DataType.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import { readIdentifierToken } from "./readIdentifierToken.js";
+
+
+/**
+ *
+ * @param {String} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readReferenceToken(text, cursor, length) {
+    let i = cursor;
+
+    const identifiers = [];
+
+    let identifier;
+
+    identifier = readIdentifierToken(text, i, length);
+
+    identifiers.push(identifier);
+
+    i = identifier.end;
+
+    for (; ;) {
+
+        const firstChar = text.charAt(i);
+
+        if (firstChar !== '.') {
+            break;
+        }
+
+        //skip over the separator
+        i++;
+
+        identifier = readIdentifierToken(text, i, length);
+
+        identifiers.push(identifier);
+
+        i = identifier.end;
+    }
+
+    return new Token(identifiers, cursor, i, TokenType.Reference, DataType.String);
+}
+
+

package/src/core/parser/simple/readReferenceToken.spec.js

@@ -0,0 +1,18 @@
+import { readReferenceToken } from "./readReferenceToken.js";
+import TokenType from "./TokenType.js";
+
+test('parse reference a.b', () => {
+    const token = readReferenceToken('a.b', 0, 3);
+
+    expect(token.end).toBe(3);
+    expect(token.start).toBe(0);
+    expect(token.name).toBe(TokenType.Reference);
+
+    const identifiers = token.value;
+
+    expect(Array.isArray(identifiers)).toBe(true);
+    expect(identifiers.length).toBe(2);
+
+    expect(identifiers[0].value).toBe('a');
+    expect(identifiers[1].value).toBe('b');
+});

package/src/core/parser/simple/readStringToken.js

@@ -0,0 +1,94 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @returns {string}
+ */
+function readQuote(text, cursor) {
+    const char = text.charAt(cursor);
+
+    if (char !== '"' && char !== '\'') {
+        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
+    }
+
+    return char;
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readStringToken(text, cursor, length) {
+    let i = cursor;
+
+    const openingQuote = readQuote(text, i);
+
+    i++;
+
+    let char;
+
+    let value = '';
+    const lastPossibleChar = length - 1;
+
+    for (; i < lastPossibleChar; i++) {
+        char = text.charAt(i);
+
+        if (char === '\\') {
+            i++;
+            //read escape sequence
+            char = text.charAt(i);
+
+            switch (char) {
+                case 'n':
+                    value += '\n';
+                    break;
+                case 't':
+                    value += '\t';
+                    break;
+                case 'r':
+                    value += '\r';
+                    break;
+                case 'b':
+                    value += '\b';
+                    break;
+                case 'f':
+                    value += '\f';
+                    break;
+                case 'v':
+                    value += '\v';
+                    break;
+                case '0':
+                    value += '\0';
+                    break;
+                case '\\':
+                case "'":
+                case '"':
+                default:
+                    value += char;
+                    break;
+            }
+        } else if (char !== openingQuote) {
+            value += char;
+        } else {
+            break;
+        }
+    }
+
+    char = text.charAt(i);
+
+    if (char !== openingQuote) {
+        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
+    }
+
+    i++;
+
+    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
+}

package/src/core/parser/simple/readStringToken.spec.js

@@ -0,0 +1,57 @@
+import { readStringToken } from "./readStringToken.js";
+
+test('parse empty string literal', () => {
+    const token = readStringToken('""', 0, 2);
+
+    expect(token.value).toBe("");
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(2);
+});
+
+test('parse short string literal', () => {
+    const token = readStringToken('"1"', 0, 3);
+
+    expect(token.value).toBe("1");
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(3);
+});
+
+test('parse short string literal from longer input', () => {
+    const token = readStringToken('"1"  ', 0, 5);
+
+    expect(token.value).toBe("1");
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(3);
+});
+
+test('parse long string literal', () => {
+    const token = readStringToken('"hello world"', 0, 13);
+
+    expect(token.value).toBe("hello world");
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(13);
+});
+
+test('parse a single escaped quote string literal', () => {
+    const token = readStringToken('"\\""', 0, 4);
+
+    expect(token.value).toBe('\"');
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(4);
+});
+
+test('parse string literal with escaped quotes', () => {
+    const token = readStringToken('"what is \\"?"', 0, 13);
+
+    expect(token.value).toBe('what is "?');
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(13);
+});
+
+test('parse string literal sequential escape sequences', () => {
+    const token = readStringToken('"\\n\\t"', 0, 6);
+
+    expect(token.value).toBe('\n\t');
+    expect(token.start).toBe(0);
+    expect(token.end).toBe(6);
+});

package/src/core/parser/simple/{readUnsignedInteger.js → readUnsignedIntegerToken.js}

@@ -9,7 +9,7 @@ import DataType from "./DataType.js";
  * @param {number} length
  * @returns {Token}
  */
-export function readUnsignedInteger(text, cursor, length) {
+export function readUnsignedIntegerToken(text, cursor, length) {
     let i = cursor;
 
     let value = 0;

package/src/core/parser/simple/readUnsignedIntegerToken.spec.js

@@ -0,0 +1,6 @@
+import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.js";
+
+test("sequence with all digits", () => {
+    const token = readUnsignedIntegerToken("1234567890", 0, 10);
+    expect(token.value).toEqual(1234567890);
+});