bare-script 3.5.5 → 3.7.0

package/lib/parser.js

@@ -9,14 +9,18 @@
  *
  * @param {string|string[]} scriptText - The [script text](./language/)
  * @param {number} [startLineNumber = 1] - The script's starting line number
+ * @param {?string} [scriptName = null] - The script name
  * @returns {Object} The [BareScript model](./model/#var.vName='BareScript')
  * @throws [BareScriptParserError]{@link module:lib/parser.BareScriptParserError}
  */
-export function parseScript(scriptText, startLineNumber = 1) {
-    const script = {'statements': []};
+export function parseScript(scriptText, startLineNumber = 1, scriptName = null) {
+    const lines = [];
+    const script = {'statements': [], 'scriptLines': lines};
+    if (scriptName !== null) {
+        script.scriptName = scriptName;
+    }
 
     // Line-split all script text
-    const lines = [];
     if (typeof scriptText === 'string') {
         lines.push(...scriptText.split(rScriptLineSplit));
     } else {
@@ -64,6 +68,13 @@ export function parseScript(scriptText, startLineNumber = 1) {
             line = linePart;
         }
 
+        // Base statement members
+        const lineNumber = ixLine + 1;
+        const statementBase = {lineNumber};
+        if (ixLine !== ixLinePart) {
+            statementBase.lineCount = (ixLinePart - ixLine) + 1;
+        }
+
         // Assignment?
         const matchAssignment = line.match(rScriptAssignment);
         if (matchAssignment !== null) {
@@ -71,14 +82,15 @@ export function parseScript(scriptText, startLineNumber = 1) {
                 const exprStatement = {
                     'expr': {
                         'name': matchAssignment.groups.name,
-                        'expr': parseExpression(matchAssignment.groups.expr)
+                        'expr': parseExpression(matchAssignment.groups.expr, lineNumber, scriptName, true),
+                        ...statementBase
                     }
                 };
                 statements.push(exprStatement);
                 continue;
             } catch (error) {
                 const columnNumber = line.length - matchAssignment.groups.expr.length + error.columnNumber;
-                throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine);
+                throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
             }
         }
 
@@ -87,7 +99,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
         if (matchFunctionBegin !== null) {
             // Nested function definitions are not allowed
             if (functionDef !== null) {
-                throw new BareScriptParserError('Nested function definition', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('Nested function definition', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Add the function definition statement
@@ -95,7 +107,8 @@ export function parseScript(scriptText, startLineNumber = 1) {
             functionDef = {
                 'function': {
                     'name': matchFunctionBegin.groups.name,
-                    'statements': []
+                    'statements': [],
+                    ...statementBase
                 }
             };
             if (typeof matchFunctionBegin.groups.args !== 'undefined') {
@@ -115,7 +128,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
         const matchFunctionEnd = line.match(rScriptFunctionEnd);
         if (matchFunctionEnd !== null) {
             if (functionDef === null) {
-                throw new BareScriptParserError('No matching function definition', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('No matching function definition', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Check for un-matched label definitions
@@ -123,7 +136,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
                 const labelDef = labelDefs.pop();
                 const [defKey] = Object.keys(labelDef);
                 const def = labelDef[defKey];
-                throw new BareScriptParserError(`Missing end${defKey} statement`, def.line, 1, def.lineNumber);
+                throw new BareScriptParserError(`Missing end${defKey} statement`, def.line, 1, def.lineNumber, scriptName);
             }
 
             functionDef = null;
@@ -138,7 +151,8 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const ifthen = {
                 'jump': {
                     'label': `__bareScriptIf${labelIndex}`,
-                    'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfBegin.groups.expr)}}
+                    'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfBegin.groups.expr, lineNumber, scriptName, true)}},
+                    ...statementBase
                 },
                 'done': `__bareScriptDone${labelIndex}`,
                 'hasElse': false,
@@ -160,26 +174,27 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const labelDefDepth = (functionDef !== null ? functionLabelDefDepth : 0);
             const ifthen = (labelDefs.length > labelDefDepth ? (labelDefs[labelDefs.length - 1].if ?? null) : null);
             if (ifthen === null) {
-                throw new BareScriptParserError('No matching if statement', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('No matching if statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Cannot come after the else-then statement
             if (ifthen.hasElse) {
-                throw new BareScriptParserError('Elif statement following else statement', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('Elif statement following else statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Generate the next if-then jump statement
             const prevLabel = ifthen.jump.label;
             ifthen.jump = {
                 'label': `__bareScriptIf${labelIndex}`,
-                'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfElseIf.groups.expr)}}
+                'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfElseIf.groups.expr, lineNumber, scriptName, true)}},
+                ...statementBase
             };
             labelIndex += 1;
 
             // Add the if-then else statements
             statements.push(
-                {'jump': {'label': ifthen.done}},
-                {'label': prevLabel},
+                {'jump': {'label': ifthen.done, ...statementBase}},
+                {'label': {'name': prevLabel, ...statementBase}},
                 {'jump': ifthen.jump}
             );
             continue;
@@ -192,19 +207,19 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const labelDefDepth = (functionDef !== null ? functionLabelDefDepth : 0);
             const ifthen = (labelDefs.length > labelDefDepth ? (labelDefs[labelDefs.length - 1].if ?? null) : null);
             if (ifthen === null) {
-                throw new BareScriptParserError('No matching if statement', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('No matching if statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Cannot have multiple else-then statements
             if (ifthen.hasElse) {
-                throw new BareScriptParserError('Multiple else statements', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('Multiple else statements', line, 1, startLineNumber + ixLine, scriptName);
             }
             ifthen.hasElse = true;
 
             // Add the if-then else statements
             statements.push(
-                {'jump': {'label': ifthen.done}},
-                {'label': ifthen.jump.label}
+                {'jump': {'label': ifthen.done, ...statementBase}},
+                {'label': {'name': ifthen.jump.label, ...statementBase}}
             );
             continue;
         }
@@ -216,7 +231,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const labelDefDepth = (functionDef !== null ? functionLabelDefDepth : 0);
             const ifthen = (labelDefs.length > labelDefDepth ? (labelDefs.pop().if ?? null) : null);
             if (ifthen === null) {
-                throw new BareScriptParserError('No matching if statement', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('No matching if statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Update the previous jump statement's label, if necessary
@@ -225,7 +240,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
             }
 
             // Add the if-then footer statement
-            statements.push({'label': ifthen.done});
+            statements.push({'label': {'name': ifthen.done, ...statementBase}});
             continue;
         }
 
@@ -237,7 +252,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
                 'loop': `__bareScriptLoop${labelIndex}`,
                 'continue': `__bareScriptLoop${labelIndex}`,
                 'done': `__bareScriptDone${labelIndex}`,
-                'expr': parseExpression(matchWhileBegin.groups.expr),
+                'expr': parseExpression(matchWhileBegin.groups.expr, lineNumber, scriptName, true),
                 line,
                 'lineNumber': startLineNumber + ixLine
             };
@@ -246,8 +261,8 @@ export function parseScript(scriptText, startLineNumber = 1) {
 
             // Add the while-do header statements
             statements.push(
-                {'jump': {'label': whiledo.done, 'expr': {'unary': {'op': '!', 'expr': whiledo.expr}}}},
-                {'label': whiledo.loop}
+                {'jump': {'label': whiledo.done, 'expr': {'unary': {'op': '!', 'expr': whiledo.expr}}, ...statementBase}},
+                {'label': {'name': whiledo.loop, ...statementBase}}
             );
             continue;
         }
@@ -259,13 +274,13 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const labelDefDepth = (functionDef !== null ? functionLabelDefDepth : 0);
             const whiledo = (labelDefs.length > labelDefDepth ? (labelDefs.pop().while ?? null) : null);
             if (whiledo === null) {
-                throw new BareScriptParserError('No matching while statement', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('No matching while statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Add the while-do footer statements
             statements.push(
-                {'jump': {'label': whiledo.loop, 'expr': whiledo.expr}},
-                {'label': whiledo.done}
+                {'jump': {'label': whiledo.loop, 'expr': whiledo.expr, ...statementBase}},
+                {'label': {'name': whiledo.done, ...statementBase}}
             );
             continue;
         }
@@ -290,17 +305,23 @@ export function parseScript(scriptText, startLineNumber = 1) {
 
             // Add the for-each header statements
             statements.push(
-                {'expr': {'name': foreach.values, 'expr': parseExpression(matchForBegin.groups.values)}},
+                {'expr': {
+                    'name': foreach.values,
+                    'expr': parseExpression(matchForBegin.groups.values, lineNumber, scriptName, true),
+                    ...statementBase
+                }},
                 {'expr': {
                     'name': foreach.length,
-                    'expr': {'function': {'name': 'arrayLength', 'args': [{'variable': foreach.values}]}}
+                    'expr': {'function': {'name': 'arrayLength', 'args': [{'variable': foreach.values}]}},
+                    ...statementBase
                 }},
-                {'jump': {'label': foreach.done, 'expr': {'unary': {'op': '!', 'expr': {'variable': foreach.length}}}}},
-                {'expr': {'name': foreach.index, 'expr': {'number': 0}}},
-                {'label': foreach.loop},
+                {'jump': {'label': foreach.done, 'expr': {'unary': {'op': '!', 'expr': {'variable': foreach.length}}}, ...statementBase}},
+                {'expr': {'name': foreach.index, 'expr': {'number': 0}, ...statementBase}},
+                {'label': {'name': foreach.loop, ...statementBase}},
                 {'expr': {
                     'name': foreach.value,
-                    'expr': {'function': {'name': 'arrayGet', 'args': [{'variable': foreach.values}, {'variable': foreach.index}]}}
+                    'expr': {'function': {'name': 'arrayGet', 'args': [{'variable': foreach.values}, {'variable': foreach.index}]}},
+                    ...statementBase
                 }}
             );
             continue;
@@ -313,23 +334,25 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const labelDefDepth = (functionDef !== null ? functionLabelDefDepth : 0);
             const foreach = (labelDefs.length > labelDefDepth ? (labelDefs.pop().for ?? null) : null);
             if (foreach === null) {
-                throw new BareScriptParserError('No matching for statement', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('No matching for statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
             // Add the for-each footer statements
             if (foreach.hasContinue) {
-                statements.push({'label': foreach.continue});
+                statements.push({'label': {'name': foreach.continue, ...statementBase}});
             }
             statements.push(
                 {'expr': {
                     'name': foreach.index,
-                    'expr': {'binary': {'op': '+', 'left': {'variable': foreach.index}, 'right': {'number': 1}}}
+                    'expr': {'binary': {'op': '+', 'left': {'variable': foreach.index}, 'right': {'number': 1}}},
+                    ...statementBase
                 }},
                 {'jump': {
                     'label': foreach.loop,
-                    'expr': {'binary': {'op': '<', 'left': {'variable': foreach.index}, 'right': {'variable': foreach.length}}}
+                    'expr': {'binary': {'op': '<', 'left': {'variable': foreach.index}, 'right': {'variable': foreach.length}}},
+                    ...statementBase
                 }},
-                {'label': foreach.done}
+                {'label': {'name': foreach.done, ...statementBase}}
             );
             continue;
         }
@@ -342,13 +365,13 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const ixLabelDef = labelDefs.findLastIndex((def) => !('if' in def));
             const labelDef = (ixLabelDef >= labelDefDepth ? labelDefs[ixLabelDef] : null);
             if (labelDef === null) {
-                throw new BareScriptParserError('Break statement outside of loop', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('Break statement outside of loop', line, 1, startLineNumber + ixLine, scriptName);
             }
             const [labelKey] = Object.keys(labelDef);
             const loopDef = labelDef[labelKey];
 
             // Add the break jump statement
-            statements.push({'jump': {'label': loopDef.done}});
+            statements.push({'jump': {'label': loopDef.done, ...statementBase}});
             continue;
         }
 
@@ -360,34 +383,34 @@ export function parseScript(scriptText, startLineNumber = 1) {
             const ixLabelDef = labelDefs.findLastIndex((def) => !('if' in def));
             const labelDef = (ixLabelDef >= labelDefDepth ? labelDefs[ixLabelDef] : null);
             if (labelDef === null) {
-                throw new BareScriptParserError('Continue statement outside of loop', line, 1, startLineNumber + ixLine);
+                throw new BareScriptParserError('Continue statement outside of loop', line, 1, startLineNumber + ixLine, scriptName);
             }
             const [labelKey] = Object.keys(labelDef);
             const loopDef = labelDef[labelKey];
 
             // Add the continue jump statement
             loopDef.hasContinue = true;
-            statements.push({'jump': {'label': loopDef.continue}});
+            statements.push({'jump': {'label': loopDef.continue, ...statementBase}});
             continue;
         }
 
         // Label definition?
         const matchLabel = line.match(rScriptLabel);
         if (matchLabel !== null) {
-            statements.push({'label': matchLabel.groups.name});
+            statements.push({'label': {'name': matchLabel.groups.name, ...statementBase}});
             continue;
         }
 
         // Jump definition?
         const matchJump = line.match(rScriptJump);
         if (matchJump !== null) {
-            const jumpStatement = {'jump': {'label': matchJump.groups.name}};
+            const jumpStatement = {'jump': {'label': matchJump.groups.name, ...statementBase}};
             if (typeof matchJump.groups.expr !== 'undefined') {
                 try {
-                    jumpStatement.jump.expr = parseExpression(matchJump.groups.expr);
+                    jumpStatement.jump.expr = parseExpression(matchJump.groups.expr, lineNumber, scriptName, true);
                 } catch (error) {
                     const columnNumber = matchJump.groups.jump.length - matchJump.groups.expr.length - 1 + error.columnNumber;
-                    throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine);
+                    throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
                 }
             }
             statements.push(jumpStatement);
@@ -397,13 +420,13 @@ export function parseScript(scriptText, startLineNumber = 1) {
         // Return definition?
         const matchReturn = line.match(rScriptReturn);
         if (matchReturn !== null) {
-            const returnStatement = {'return': {}};
+            const returnStatement = {'return': {...statementBase}};
             if (typeof matchReturn.groups.expr !== 'undefined') {
                 try {
-                    returnStatement.return.expr = parseExpression(matchReturn.groups.expr);
+                    returnStatement.return.expr = parseExpression(matchReturn.groups.expr, lineNumber, scriptName, true);
                 } catch (error) {
                     const columnNumber = matchReturn.groups.return.length - matchReturn.groups.expr.length + error.columnNumber;
-                    throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine);
+                    throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
                 }
             }
             statements.push(returnStatement);
@@ -414,11 +437,15 @@ export function parseScript(scriptText, startLineNumber = 1) {
         const matchInclude = line.match(rScriptInclude) || line.match(rScriptIncludeSystem);
         if (matchInclude !== null) {
             const {delim} = matchInclude.groups;
-            const url = (delim === '<' ? matchInclude.groups.url : matchInclude.groups.url.replace(rExprStringEscape, '$1'));
+            const url = (
+                delim === '<' ? matchInclude.groups.url : matchInclude.groups.url.replace(rExprStringEscapes, replaceStringEscape)
+            );
             let includeStatement = (statements.length ? statements[statements.length - 1] : null);
             if (includeStatement === null || !('include' in includeStatement)) {
-                includeStatement = {'include': {'includes': []}};
+                includeStatement = {'include': {'includes': [], ...statementBase}};
                 statements.push(includeStatement);
+            } else {
+                includeStatement.include.lineCount = (ixLinePart - includeStatement.include.lineNumber) + 2;
             }
             includeStatement.include.includes.push(delim === '<' ? {url, 'system': true} : {url});
             continue;
@@ -426,10 +453,10 @@ export function parseScript(scriptText, startLineNumber = 1) {
 
         // Expression
         try {
-            const exprStatement = {'expr': {'expr': parseExpression(line)}};
+            const exprStatement = {'expr': {'expr': parseExpression(line, lineNumber, scriptName, true), ...statementBase}};
             statements.push(exprStatement);
         } catch (error) {
-            throw new BareScriptParserError(error.error, line, error.columnNumber, startLineNumber + ixLine);
+            throw new BareScriptParserError(error.error, line, error.columnNumber, startLineNumber + ixLine, scriptName);
         }
     }
 
@@ -438,7 +465,7 @@ export function parseScript(scriptText, startLineNumber = 1) {
         const labelDef = labelDefs.pop();
         const [defKey] = Object.keys(labelDef);
         const def = labelDef[defKey];
-        throw new BareScriptParserError(`Missing end${defKey} statement`, def.line, 1, def.lineNumber);
+        throw new BareScriptParserError(`Missing end${defKey} statement`, def.line, 1, def.lineNumber, scriptName);
     }
 
     return script;
@@ -480,25 +507,28 @@ const rScriptContinue = new RegExp(`^\\s*continue${rPartComment}`);
  * Parse a BareScript expression
  *
  * @param {string} exprText - The [expression text](./language/#expressions)
+ * @param {number} [lineNumber = 1] - The script line number
+ * @param {?string} [scriptName = null] - The script name
+ * @param {boolean} [arrayLiterals = false] - If True, allow parsing of array literals
  * @returns {Object} The [expression model](./model/#var.vName='Expression')
  * @throws [BareScriptParserError]{@link module:lib/parser.BareScriptParserError}
  */
-export function parseExpression(exprText) {
+export function parseExpression(exprText, lineNumber = null, scriptName = null, arrayLiterals = false) {
     try {
-        const [expr, nextText] = parseBinaryExpression(exprText);
+        const [expr, nextText] = parseBinaryExpression(exprText, null, arrayLiterals);
         if (nextText.trim() !== '') {
-            throw new BareScriptParserError('Syntax error', nextText);
+            throw new BareScriptParserError('Syntax error', nextText, 1, lineNumber, scriptName);
         }
         return expr;
     } catch (error) {
         const columnNumber = exprText.length - error.line.length + 1;
-        throw new BareScriptParserError(error.error, exprText, columnNumber);
+        throw new BareScriptParserError(error.error, exprText, columnNumber, lineNumber, scriptName);
     }
 }
 
 
 // Helper function to parse a binary operator expression chain
-function parseBinaryExpression(exprText, binLeftExpr = null) {
+function parseBinaryExpression(exprText, binLeftExpr, arrayLiterals) {
     // Parse the binary operator's left unary expression if none was passed
     let leftExpr;
     let binText;
@@ -506,7 +536,7 @@ function parseBinaryExpression(exprText, binLeftExpr = null) {
         binText = exprText;
         leftExpr = binLeftExpr;
     } else {
-        [leftExpr, binText] = parseUnaryExpression(exprText);
+        [leftExpr, binText] = parseUnaryExpression(exprText, arrayLiterals);
     }
 
     // Match a binary operator - if not found, return the left expression
@@ -523,7 +553,7 @@ function parseBinaryExpression(exprText, binLeftExpr = null) {
     const rightText = binText.slice(matchBinaryOp[0].length);
 
     // Parse the right sub-expression
-    const [rightExpr, nextText] = parseUnaryExpression(rightText);
+    const [rightExpr, nextText] = parseUnaryExpression(rightText, arrayLiterals);
 
     // Create the binary expression - re-order for binary operators as necessary
     let binExpr;
@@ -541,7 +571,7 @@ function parseBinaryExpression(exprText, binLeftExpr = null) {
     }
 
     // Parse the next binary expression in the chain
-    return parseBinaryExpression(nextText, binExpr);
+    return parseBinaryExpression(nextText, binExpr, arrayLiterals);
 }
 
 
@@ -570,15 +600,15 @@ const binaryReorder = {
 
 
 // Helper function to parse a unary expression
-function parseUnaryExpression(exprText) {
+function parseUnaryExpression(exprText, arrayLiterals) {
     // Group open?
     const matchGroupOpen = exprText.match(rExprGroupOpen);
     if (matchGroupOpen !== null) {
         const groupText = exprText.slice(matchGroupOpen[0].length);
-        const [expr, nextText] = parseBinaryExpression(groupText);
+        const [expr, nextText] = parseBinaryExpression(groupText, null, arrayLiterals);
         const matchGroupClose = nextText.match(rExprGroupClose);
         if (matchGroupClose === null) {
-            throw new BareScriptParserError('Unmatched parenthesis', exprText);
+            throw new BareScriptParserError('Unmatched parenthesis', exprText, 1, null, null);
         }
         return [{'group': expr}, nextText.slice(matchGroupClose[0].length)];
     }
@@ -595,7 +625,7 @@ function parseUnaryExpression(exprText) {
     // String?
     const matchString = exprText.match(rExprString);
     if (matchString !== null) {
-        const string = matchString[1].replace(rExprStringEscape, '$1');
+        const string = matchString[1].replace(rExprStringEscapes, replaceStringEscape);
         const expr = {'string': string};
         return [expr, exprText.slice(matchString[0].length)];
     }
@@ -603,7 +633,7 @@ function parseUnaryExpression(exprText) {
     // String (double quotes)?
     const matchStringDouble = exprText.match(rExprStringDouble);
     if (matchStringDouble !== null) {
-        const string = matchStringDouble[1].replace(rExprStringDoubleEscape, '$1');
+        const string = matchStringDouble[1].replace(rExprStringEscapes, replaceStringEscape);
         const expr = {'string': string};
         return [expr, exprText.slice(matchStringDouble[0].length)];
     }
@@ -612,7 +642,7 @@ function parseUnaryExpression(exprText) {
     const matchUnary = exprText.match(rExprUnaryOp);
     if (matchUnary !== null) {
         const unaryText = exprText.slice(matchUnary[0].length);
-        const [expr, nextText] = parseUnaryExpression(unaryText);
+        const [expr, nextText] = parseUnaryExpression(unaryText, arrayLiterals);
         const unaryExpr = {
             'unary': {
                 'op': matchUnary[1],
@@ -639,15 +669,15 @@ function parseUnaryExpression(exprText) {
             if (args.length !== 0) {
                 const matchFunctionSeparator = argText.match(rExprFunctionSeparator);
                 if (matchFunctionSeparator === null) {
-                    throw new BareScriptParserError('Syntax error', argText);
+                    throw new BareScriptParserError('Syntax error', argText, 1, null, null);
                 }
                 argText = argText.slice(matchFunctionSeparator[0].length);
             }
 
             // Get the argument
-            const [argExpr, nextArgText] = parseBinaryExpression(argText);
-            args.push(argExpr);
+            const [argExpr, nextArgText] = parseBinaryExpression(argText, null, arrayLiterals);
             argText = nextArgText;
+            args.push(argExpr);
         }
 
         const fnExpr = {
@@ -659,6 +689,84 @@ function parseUnaryExpression(exprText) {
         return [fnExpr, argText];
     }
 
+    // Object creation?
+    const matchObjectOpen = exprText.match(rExprObjectOpen);
+    if (matchObjectOpen !== null) {
+        let argText = exprText.slice(matchObjectOpen[0].length);
+        const args = [];
+        while (true) {
+            // Object close?
+            const matchObjectClose = argText.match(rExprObjectClose);
+            if (matchObjectClose !== null) {
+                argText = argText.slice(matchObjectClose[0].length);
+                break;
+            }
+
+            // Object key/value separator
+            if (args.length !== 0) {
+                const matchObjectSeparator = argText.match(rExprObjectSeparator2);
+                if (matchObjectSeparator === null) {
+                    throw new BareScriptParserError('Syntax error', argText, 1, null, null);
+                }
+                argText = argText.slice(matchObjectSeparator[0].length);
+            }
+
+            // Get the key
+            const [argKey, nextArgText] = parseBinaryExpression(argText, null, arrayLiterals);
+            argText = nextArgText;
+            args.push(argKey);
+
+            // Object key separator
+            if (args.length !== 0) {
+                const matchObjectSeparator = argText.match(rExprObjectSeparator);
+                if (matchObjectSeparator === null) {
+                    throw new BareScriptParserError('Syntax error', argText, 1, null, null);
+                }
+                argText = argText.slice(matchObjectSeparator[0].length);
+            }
+
+            // Get the value
+            const [argValue, nextArgText2] = parseBinaryExpression(argText, null, arrayLiterals);
+            argText = nextArgText2;
+            args.push(argValue);
+        }
+        const fnExpr = {'function': {'name': 'objectNew', 'args': args}};
+        return [fnExpr, argText];
+    }
+
+    // Array creation?
+    if (arrayLiterals) {
+        const matchArrayOpen = exprText.match(rExprArrayOpen);
+        if (matchArrayOpen !== null) {
+            let argText = exprText.slice(matchArrayOpen[0].length);
+            const args = [];
+            while (true) {
+                // Array close?
+                const matchArrayClose = argText.match(rExprArrayClose);
+                if (matchArrayClose !== null) {
+                    argText = argText.slice(matchArrayClose[0].length);
+                    break;
+                }
+
+                // Array value separator
+                if (args.length !== 0) {
+                    const matchArraySeparator = argText.match(rExprArraySeparator);
+                    if (matchArraySeparator === null) {
+                        throw new BareScriptParserError('Syntax error', argText, 1, null, null);
+                    }
+                    argText = argText.slice(matchArraySeparator[0].length);
+                }
+
+                // Get the value
+                const [argValue, nextArgText2] = parseBinaryExpression(argText, null, arrayLiterals);
+                argText = nextArgText2;
+                args.push(argValue);
+            }
+            const fnExpr = {'function': {'name': 'arrayNew', 'args': args}};
+            return [fnExpr, argText];
+        }
+    }
+
     // Variable?
     const matchVariable = exprText.match(rExprVariable);
     if (matchVariable !== null) {
@@ -667,14 +775,16 @@ function parseUnaryExpression(exprText) {
     }
 
     // Variable (brackets)?
-    const matchVariableEx = exprText.match(rExprVariableEx);
-    if (matchVariableEx !== null) {
-        const variableName = matchVariableEx[1].replace(rExprVariableExEscape, '$1');
-        const expr = {'variable': variableName};
-        return [expr, exprText.slice(matchVariableEx[0].length)];
+    if (!arrayLiterals) {
+        const matchVariableEx = exprText.match(rExprVariableEx);
+        if (matchVariableEx !== null) {
+            const variableName = matchVariableEx[1].replace(rExprVariableExEscape, '$1');
+            const expr = {'variable': variableName};
+            return [expr, exprText.slice(matchVariableEx[0].length)];
+        }
     }
 
-    throw new BareScriptParserError('Syntax error', exprText);
+    throw new BareScriptParserError('Syntax error', exprText, 1, null, null);
 }
 
 
@@ -688,15 +798,42 @@ const rExprFunctionClose = /^\s*\)/;
 const rExprGroupOpen = /^\s*\(/;
 const rExprGroupClose = /^\s*\)/;
 const rExprNumber = /^\s*(0x[A-Fa-f0-9]+|[+-]?\d+(?:\.\d*)?(?:e[+-]?\d+)?)/;
+const rExprArrayOpen = /^\s*\[/;
+const rExprArraySeparator = /^\s*,/;
+const rExprArrayClose = /^\s*\]/;
+const rExprObjectOpen = /^\s*\{/;
+const rExprObjectSeparator = /^\s*:/;
+const rExprObjectSeparator2 = /^\s*,/;
+const rExprObjectClose = /^\s*\}/;
 const rExprString = /^\s*'((?:\\\\|\\'|[^'])*)'/;
-const rExprStringEscape = /\\([\\'])/g;
 const rExprStringDouble = /^\s*"((?:\\\\|\\"|[^"])*)"/;
-const rExprStringDoubleEscape = /\\([\\"])/g;
 const rExprVariable = /^\s*([A-Za-z_]\w*)/;
 const rExprVariableEx = /^\s*\[\s*((?:\\\]|[^\]])+)\s*\]/;
 const rExprVariableExEscape = /\\([\\\]])/g;
 
 
+// String literal escapes
+const rExprStringEscapes = /(?<!\\)\\([nrtbf'"\\]|u[0-9a-fA-F]{4})/g;
+
+function replaceStringEscape(unusedMatch, esc) {
+    if (esc.startsWith('u')) {
+        return String.fromCharCode(parseInt(esc.slice(1), 16));
+    }
+    return exprStringEscapes[esc];
+}
+
+const exprStringEscapes = {
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+    'b': '\b',
+    'f': '\f',
+    "'": "'",
+    '"': '"',
+    '\\': '\\'
+};
+
+
 /**
  * A BareScript parser error
  *
@@ -705,6 +842,7 @@ const rExprVariableExEscape = /\\([\\\]])/g;
  * @property {string} line - The line text
  * @property {number} columnNumber - The error column number
  * @property {?number} lineNumber - The error line number
+ * @property {?string} scriptName - The error line number
  */
 export class BareScriptParserError extends Error {
     /**
@@ -712,11 +850,11 @@ export class BareScriptParserError extends Error {
      *
      * @param {string} error - The error description
      * @param {string} line - The line text
-     * @param {number} [columnNumber=1] - The error column number
-     * @param {?number} [lineNumber=null] - The error line number
-     * @param {?string} [prefix=null] - The error message prefix line
+     * @param {number} [columnNumber] - The error column number
+     * @param {?number} [lineNumber] - The error line number
+     * @param {?string} [scriptName] - The script name
      */
-    constructor(error, line, columnNumber = 1, lineNumber = null, prefix = null) {
+    constructor(error, line, columnNumber, lineNumber, scriptName) {
         // Parser error constants
         const lineLengthMax = 120;
         const lineSuffix = ' ...';
@@ -740,8 +878,9 @@ export class BareScriptParserError extends Error {
         }
 
         // Format the message
+        const errorPrefix = (lineNumber ? `${scriptName || ''}:${lineNumber}: ` : '');
         const message = `\
-${prefix !== null ? `${prefix}\n` : ''}${error}${lineNumber !== null ? `, line number ${lineNumber}` : ''}:
+${errorPrefix}${error}
 ${lineError}
 ${' '.repeat(lineColumn - 1)}^
 `;
@@ -751,5 +890,6 @@ ${' '.repeat(lineColumn - 1)}^
         this.line = line;
         this.columnNumber = columnNumber;
         this.lineNumber = lineNumber;
+        this.scriptName = scriptName;
     }
 }