bare-script 3.7.2 → 3.7.4

package/lib/bare.js

@@ -91,13 +91,13 @@ export async function main(options) {
             if (args.static || args.debug) {
                 const warnings = lintScript(script);
                 if (warnings.length === 0) {
-                    options.logFn(`BareScript: Static analysis "${scriptName}" ... OK`);
+                    options.logFn(`BareScript static analysis "${scriptName}" ... OK`);
                 } else {
                     options.logFn(
-                        `BareScript: Static analysis "${scriptName}" ... ${warnings.length} warning${warnings.length > 1 ? 's' : ''}:`
+                        `BareScript static analysis "${scriptName}" ... ${warnings.length} warning${warnings.length > 1 ? 's' : ''}:`
                     );
                     for (const warning of warnings) {
-                        options.logFn(`BareScript:     ${warning}`);
+                        options.logFn(warning);
                     }
                     if (args.static) {
                         statusCode = 1;
@@ -131,7 +131,7 @@ export async function main(options) {
             // Log script execution end with timing
             if (args.debug) {
                 const timeEnd = performance.now();
-                options.logFn(`BareScript: Script executed in ${(timeEnd - timeBegin).toFixed(1)} milliseconds`);
+                options.logFn(`BareScript executed in ${(timeEnd - timeBegin).toFixed(1)} milliseconds`);
             }
 
             // Stop on error status code

package/lib/model.js

@@ -324,21 +324,20 @@ export function validateExpression(expr) {
  */
 export function lintScript(script) {
     const warnings = [];
+    const {statements} = script;
 
     // Empty script?
-    if (script.statements.length === 0) {
-        warnings.push('Empty script');
+    if (statements.length === 0) {
+        lintScriptWarning(warnings, script, null, 'Empty script');
     }
 
     // Variable used before assignment?
     const varAssigns = {};
     const varUses = {};
-    getVariableAssignmentsAndUses(script.statements, varAssigns, varUses);
+    getVariableAssignmentsAndUses(statements, varAssigns, varUses);
     for (const varName of Object.keys(varAssigns)) {
         if (varName in varUses && varUses[varName] <= varAssigns[varName]) {
-            warnings.push(
-                `Global variable "${varName}" used (index ${varUses[varName]}) before assignment (index ${varAssigns[varName]})`
-            );
+            lintScriptWarning(warnings, script, statements[varUses[varName]], `Global variable "${varName}" used before assignment`);
         }
     }
 
@@ -346,14 +345,14 @@ export function lintScript(script) {
     const functionsDefined = {};
     const labelsDefined = {};
     const labelsUsed = {};
-    for (const [ixStatement, statement] of script.statements.entries()) {
+    for (const [ixStatement, statement] of statements.entries()) {
         const [statementKey] = Object.keys(statement);
 
         // Function definition checks
         if (statementKey === 'function') {
             // Function redefinition?
             if (statement.function.name in functionsDefined) {
-                warnings.push(`Redefinition of function "${statement.function.name}" (index ${ixStatement})`);
+                lintScriptWarning(warnings, script, statement, `Redefinition of function "${statement.function.name}"`);
             } else {
                 functionsDefined[statement.function.name] = ixStatement;
             }
@@ -369,9 +368,9 @@ export function lintScript(script) {
                     continue;
                 }
                 if (varName in fnVarUses && fnVarUses[varName] <= fnVarAssigns[varName]) {
-                    warnings.push(
-                        `Variable "${varName}" of function "${statement.function.name}" used (index ${fnVarUses[varName]}) ` +
-                            `before assignment (index ${fnVarAssigns[varName]})`
+                    lintScriptWarning(
+                        warnings, script, statement,
+                        `Variable "${varName}" of function "${statement.function.name}" used before assignment`
                     );
                 }
             }
@@ -379,8 +378,9 @@ export function lintScript(script) {
             // Unused variables?
             for (const varName of Object.keys(fnVarAssigns)) {
                 if (!(varName in fnVarUses)) {
-                    warnings.push(
-                        `Unused variable "${varName}" defined in function "${statement.function.name}" (index ${fnVarAssigns[varName]})`
+                    lintScriptWarning(
+                        warnings, script, statement,
+                        `Unused variable "${varName}" defined in function "${statement.function.name}"`
                     );
                 }
             }
@@ -391,13 +391,17 @@ export function lintScript(script) {
                 for (const arg of args) {
                     // Duplicate argument?
                     if (argsDefined.has(arg)) {
-                        warnings.push(`Duplicate argument "${arg}" of function "${statement.function.name}" (index ${ixStatement})`);
+                        lintScriptWarning(
+                            warnings, script, statement, `Duplicate argument "${arg}" of function "${statement.function.name}"`
+                        );
                     } else {
                         argsDefined.add(arg);
 
                         // Unused argument?
                         if (!(arg in fnVarUses)) {
-                            warnings.push(`Unused argument "${arg}" of function "${statement.function.name}" (index ${ixStatement})`);
+                            lintScriptWarning(
+                                warnings, script, statement, `Unused argument "${arg}" of function "${statement.function.name}"`
+                            );
                         }
                     }
                 }
@@ -413,7 +417,7 @@ export function lintScript(script) {
                 if (fnStatementKey === 'expr') {
                     // Pointless function expression statement?
                     if (!('name' in fnStatement.expr) && isPointlessExpression(fnStatement.expr.expr)) {
-                        warnings.push(`Pointless statement in function "${statement.function.name}" (index ${ixFnStatement})`);
+                        lintScriptWarning(warnings, script, statement, `Pointless statement in function "${statement.function.name}"`);
                     }
 
                 // Function label statement checks
@@ -421,8 +425,9 @@ export function lintScript(script) {
                     // Label redefinition?
                     const fnStatementLabel = fnStatement.label.name;
                     if (fnStatementLabel in fnLabelsDefined) {
-                        warnings.push(
-                            `Redefinition of label "${fnStatementLabel}" in function "${statement.function.name}" (index ${ixFnStatement})`
+                        lintScriptWarning(
+                            warnings, script, statement,
+                            `Redefinition of label "${fnStatementLabel}" in function "${statement.function.name}"`
                         );
                     } else {
                         fnLabelsDefined[fnStatementLabel] = ixFnStatement;
@@ -439,14 +444,14 @@ export function lintScript(script) {
             // Unused function labels?
             for (const label of Object.keys(fnLabelsDefined)) {
                 if (!(label in fnLabelsUsed)) {
-                    warnings.push(`Unused label "${label}" in function "${statement.function.name}" (index ${fnLabelsDefined[label]})`);
+                    lintScriptWarning(warnings, script, statement, `Unused label "${label}" in function "${statement.function.name}"`);
                 }
             }
 
             // Unknown function labels?
             for (const label of Object.keys(fnLabelsUsed)) {
                 if (!(label in fnLabelsDefined)) {
-                    warnings.push(`Unknown label "${label}" in function "${statement.function.name}" (index ${fnLabelsUsed[label]})`);
+                    lintScriptWarning(warnings, script, statement, `Unknown label "${label}" in function "${statement.function.name}"`);
                 }
             }
 
@@ -454,7 +459,7 @@ export function lintScript(script) {
         } else if (statementKey === 'expr') {
             // Pointless global expression statement?
             if (!('name' in statement.expr) && isPointlessExpression(statement.expr.expr)) {
-                warnings.push(`Pointless global statement (index ${ixStatement})`);
+                lintScriptWarning(warnings, script, statement, 'Pointless global statement');
             }
 
         // Global label statement checks
@@ -462,7 +467,7 @@ export function lintScript(script) {
             // Label redefinition?
             const statementLabel = statement.label.name;
             if (statementLabel in labelsDefined) {
-                warnings.push(`Redefinition of global label "${statementLabel}" (index ${ixStatement})`);
+                lintScriptWarning(warnings, script, statement, `Redefinition of global label "${statementLabel}"`);
             } else {
                 labelsDefined[statementLabel] = ixStatement;
             }
@@ -478,14 +483,14 @@ export function lintScript(script) {
     // Unused global labels?
     for (const label of Object.keys(labelsDefined)) {
         if (!(label in labelsUsed)) {
-            warnings.push(`Unused global label "${label}" (index ${labelsDefined[label]})`);
+            lintScriptWarning(warnings, script, statements[labelsDefined[label]], `Unused global label "${label}"`);
         }
     }
 
     // Unknown global labels?
     for (const label of Object.keys(labelsUsed)) {
         if (!(label in labelsDefined)) {
-            warnings.push(`Unknown global label "${label}" (index ${labelsUsed[label]})`);
+            lintScriptWarning(warnings, script, statements[labelsUsed[label]], `Unknown global label "${label}"`);
         }
     }
 
@@ -493,6 +498,14 @@ export function lintScript(script) {
 }
 
 
+// Helper to format static analysis warnings
+function lintScriptWarning(warnings, script, statement, message) {
+    const scriptName = script.scriptName ?? '';
+    const lineno = (statement !== null ? (statement[Object.keys(statement)[0]].lineNumber ?? 1) : 1);
+    warnings.push(`${scriptName}:${lineno}: ${message}`);
+}
+
+
 // Helper function to determine if an expression statement's expression is pointless
 function isPointlessExpression(expr) {
     const [exprKey] = Object.keys(expr);

package/lib/parser.js

@@ -78,20 +78,25 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
         // Assignment?
         const matchAssignment = line.match(rScriptAssignment);
         if (matchAssignment !== null) {
+            // Parse the expression
+            let assignmentExpr;
             try {
-                const exprStatement = {
-                    'expr': {
-                        'name': matchAssignment.groups.name,
-                        'expr': parseExpression(matchAssignment.groups.expr, lineNumber, scriptName, true),
-                        ...statementBase
-                    }
-                };
-                statements.push(exprStatement);
-                continue;
+                assignmentExpr = parseExpression(matchAssignment.groups.expr, lineNumber, scriptName, true);
             } catch (error) {
                 const columnNumber = line.length - matchAssignment.groups.expr.length + error.columnNumber;
                 throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
             }
+
+            // Add the expression statement
+            const exprStatement = {
+                'expr': {
+                    'name': matchAssignment.groups.name,
+                    'expr': assignmentExpr,
+                    ...statementBase
+                }
+            };
+            statements.push(exprStatement);
+            continue;
         }
 
         // Function definition begin?
@@ -147,11 +152,20 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
         // If-then begin?
         const matchIfBegin = line.match(rScriptIfBegin);
         if (matchIfBegin !== null) {
+            // Parse the if-then expression
+            let ifthenExpr;
+            try {
+                ifthenExpr = parseExpression(matchIfBegin.groups.expr, lineNumber, scriptName, true);
+            } catch (error) {
+                const columnNumber = matchIfBegin.groups.if.length + error.columnNumber;
+                throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
+            }
+
             // Add the if-then label definition
             const ifthen = {
                 'jump': {
                     'label': `__bareScriptIf${labelIndex}`,
-                    'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfBegin.groups.expr, lineNumber, scriptName, true)}},
+                    'expr': {'unary': {'op': '!', 'expr': ifthenExpr}},
                     ...statementBase
                 },
                 'done': `__bareScriptDone${labelIndex}`,
@@ -170,7 +184,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
         // Else-if-then?
         const matchIfElseIf = line.match(rScriptIfElseIf);
         if (matchIfElseIf !== null) {
-            // Get the if-then definition
+            // Get the else-if-then definition
             const labelDefDepth = (functionDef !== null ? functionLabelDefDepth : 0);
             const ifthen = (labelDefs.length > labelDefDepth ? (labelDefs[labelDefs.length - 1].if ?? null) : null);
             if (ifthen === null) {
@@ -182,11 +196,20 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
                 throw new BareScriptParserError('Elif statement following else statement', line, 1, startLineNumber + ixLine, scriptName);
             }
 
+            // Parse the else-if-then expression
+            let ifElseIfExpr;
+            try {
+                ifElseIfExpr = parseExpression(matchIfElseIf.groups.expr, lineNumber, scriptName, true);
+            } catch (error) {
+                const columnNumber = matchIfElseIf.groups.elif.length + error.columnNumber;
+                throw new BareScriptParserError(error.error, line, columnNumber, 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, lineNumber, scriptName, true)}},
+                'expr': {'unary': {'op': '!', 'expr': ifElseIfExpr}},
                 ...statementBase
             };
             labelIndex += 1;
@@ -247,12 +270,21 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
         // While-do begin?
         const matchWhileBegin = line.match(rScriptWhileBegin);
         if (matchWhileBegin !== null) {
+            // Parse the while-do expression
+            let whileBeginExpr;
+            try {
+                whileBeginExpr = parseExpression(matchWhileBegin.groups.expr, lineNumber, scriptName, true);
+            } catch (error) {
+                const columnNumber = matchWhileBegin.groups.while.length + error.columnNumber;
+                throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
+            }
+
             // Add the while-do label
             const whiledo = {
                 'loop': `__bareScriptLoop${labelIndex}`,
                 'continue': `__bareScriptLoop${labelIndex}`,
                 'done': `__bareScriptDone${labelIndex}`,
-                'expr': parseExpression(matchWhileBegin.groups.expr, lineNumber, scriptName, true),
+                'expr': whileBeginExpr,
                 line,
                 'lineNumber': startLineNumber + ixLine
             };
@@ -303,11 +335,20 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
             labelDefs.push({'for': foreach});
             labelIndex += 1;
 
+            // Parse the for-each expression
+            let forBeginExpr;
+            try {
+                forBeginExpr = parseExpression(matchForBegin.groups.values, lineNumber, scriptName, true);
+            } catch (error) {
+                const columnNumber = matchForBegin.groups.for.length + error.columnNumber;
+                throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
+            }
+
             // Add the for-each header statements
             statements.push(
                 {'expr': {
                     'name': foreach.values,
-                    'expr': parseExpression(matchForBegin.groups.values, lineNumber, scriptName, true),
+                    'expr': forBeginExpr,
                     ...statementBase
                 }},
                 {'expr': {
@@ -489,15 +530,15 @@ const rScriptJump = new RegExp(`^(?<jump>\\s*(?:jump|jumpif\\s*\\((?<expr>.+)\\)
 const rScriptReturn = new RegExp(`^(?<return>\\s*return(?:\\s+(?<expr>[^#\\s].*))?)${rPartComment}`);
 const rScriptInclude = new RegExp(`^\\s*include\\s+(?<delim>')(?<url>(?:\\'|[^'])*)'${rPartComment}`);
 const rScriptIncludeSystem = new RegExp(`^\\s*include\\s+(?<delim><)(?<url>[^>]*)>${rPartComment}`);
-const rScriptIfBegin = new RegExp(`^\\s*if\\s+(?<expr>.+)\\s*:${rPartComment}`);
-const rScriptIfElseIf = new RegExp(`^\\s*elif\\s+(?<expr>.+)\\s*:${rPartComment}`);
+const rScriptIfBegin = new RegExp(`^(?<if>\\s*if\\s+)(?<expr>.+)\\s*:${rPartComment}`);
+const rScriptIfElseIf = new RegExp(`^(?<elif>\\s*elif\\s+)(?<expr>.+)\\s*:${rPartComment}`);
 const rScriptIfElse = new RegExp(`^\\s*else\\s*:${rPartComment}`);
 const rScriptIfEnd = new RegExp(`^\\s*endif${rPartComment}`);
 const rScriptForBegin = new RegExp(
-    `^\\s*for\\s+(?<value>[A-Za-z_]\\w*)(?:\\s*,\\s*(?<index>[A-Za-z_]\\w*))?\\s+in\\s+(?<values>.+)\\s*:${rPartComment}`
+    `^(?<for>\\s*for\\s+(?<value>[A-Za-z_]\\w*)(?:\\s*,\\s*(?<index>[A-Za-z_]\\w*))?\\s+in\\s+)(?<values>.+)\\s*:${rPartComment}`
 );
 const rScriptForEnd = new RegExp(`^\\s*endfor${rPartComment}`);
-const rScriptWhileBegin = new RegExp(`^\\s*while\\s+(?<expr>.+)\\s*:${rPartComment}`);
+const rScriptWhileBegin = new RegExp(`^(?<while>\\s*while\\s+)(?<expr>.+)\\s*:${rPartComment}`);
 const rScriptWhileEnd = new RegExp(`^\\s*endwhile${rPartComment}`);
 const rScriptBreak = new RegExp(`^\\s*break${rPartComment}`);
 const rScriptContinue = new RegExp(`^\\s*continue${rPartComment}`);
@@ -702,9 +743,9 @@ function parseUnaryExpression(exprText, arrayLiterals) {
                 break;
             }
 
-            // Object key/value separator
+            // Key/value pair separator
             if (args.length !== 0) {
-                const matchObjectSeparator = argText.match(rExprObjectSeparator2);
+                const matchObjectSeparator = argText.match(rExprObjectSeparator);
                 if (matchObjectSeparator === null) {
                     throw new BareScriptParserError('Syntax error', argText, 1, null, null);
                 }
@@ -716,13 +757,13 @@ function parseUnaryExpression(exprText, arrayLiterals) {
             argText = nextArgText;
             args.push(argKey);
 
-            // Object key separator
+            // Key/value separator
             if (args.length !== 0) {
-                const matchObjectSeparator = argText.match(rExprObjectSeparator);
-                if (matchObjectSeparator === null) {
+                const matchObjectSeparatorKey = argText.match(rExprObjectSeparatorKey);
+                if (matchObjectSeparatorKey === null) {
                     throw new BareScriptParserError('Syntax error', argText, 1, null, null);
                 }
-                argText = argText.slice(matchObjectSeparator[0].length);
+                argText = argText.slice(matchObjectSeparatorKey[0].length);
             }
 
             // Get the value
@@ -802,8 +843,8 @@ const rExprArrayOpen = /^\s*\[/;
 const rExprArraySeparator = /^\s*,/;
 const rExprArrayClose = /^\s*\]/;
 const rExprObjectOpen = /^\s*\{/;
-const rExprObjectSeparator = /^\s*:/;
-const rExprObjectSeparator2 = /^\s*,/;
+const rExprObjectSeparatorKey = /^\s*:/;
+const rExprObjectSeparator = /^\s*,/;
 const rExprObjectClose = /^\s*\}/;
 const rExprString = /^\s*'((?:\\\\|\\'|[^'])*)'/;
 const rExprStringDouble = /^\s*"((?:\\\\|\\"|[^"])*)"/;
@@ -842,7 +883,7 @@ const exprStringEscapes = {
  * @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
+ * @property {?string} scriptName - The script name
  */
 export class BareScriptParserError extends Error {
     /**

package/lib/runtimeAsync.js

@@ -173,7 +173,7 @@ async function executeScriptHelperAsync(script, statements, options, locals) {
                     if (warnings.length) {
                         options.logFn(`${warningPrefix} ${warnings.length} warning${warnings.length > 1 ? 's' : ''}:`);
                         for (const warning of warnings) {
-                            options.logFn(`BareScript:     ${warning}`);
+                            options.logFn(`BareScript: ${warning}`);
                         }
                     }
                 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "bare-script",
-    "version": "3.7.2",
+    "version": "3.7.4",
     "description": "BareScript; a lightweight scripting and expression language",
     "keywords": [
         "expression",