@woosh/meep-engine 2.49.6 → 2.49.7

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);
+});