@irrelon/battlescript 3.1.5 → 3.1.7

package/bin/functionality.ts

@@ -9,16 +9,29 @@ import {
 	fromSourceCodeToMiniAst,
 	miniAstFromBinaryBuffer
 } from "@/services";
+import type {SourceResolverAsync, SourceResolverSync} from "@/types";
 import type {ByteCodeJson} from "@/types/byteCode/ByteCodeJson";
 import {version} from "../package.json";
 import {readFileSync} from "fs";
 import {writeFileSync} from "node:fs";
 
+const sourceResolverAsync: SourceResolverAsync = (filePath: string) => {
+	return readFile(filePath, "utf-8")
+};
+
+const sourceResolverSync: SourceResolverSync = (filePath: string): string => {
+	return readFileSync(filePath, "utf-8")
+};
+
 export async function toAst(inputPath: string, outputPath?: string) {
 	console.log(`[BattleScript ${version}] toAst: ${inputPath}`);
 	try {
-		const sourceCode = await readFile(inputPath, "utf-8");
-		const ast = fromSourceCodeToFullAst(sourceCode, {filePath: inputPath, includeMetaData: true});
+		const sourceCode = await sourceResolverAsync(inputPath);
+		const ast = fromSourceCodeToFullAst(sourceCode, {
+			filePath: inputPath,
+			includeMetaData: true,
+			sourceResolver: sourceResolverSync
+		});
 
 		if (outputPath) {
 			await writeFile(outputPath, JSON.stringify(ast, null, 2));
@@ -35,8 +48,12 @@ export async function toAst(inputPath: string, outputPath?: string) {
 export function toAstSync(inputPath: string, outputPath?: string) {
 	console.log(`[BattleScript ${version}] toAstSync: ${inputPath}`);
 	try {
-		const sourceCode = readFileSync(inputPath, "utf-8");
-		const ast = fromSourceCodeToFullAst(sourceCode, {filePath: inputPath, includeMetaData: true});
+		const sourceCode = sourceResolverSync(inputPath);
+		const ast = fromSourceCodeToFullAst(sourceCode, {
+			filePath: inputPath,
+			includeMetaData: true,
+			sourceResolver: sourceResolverSync
+		});
 
 		if (outputPath) {
 			writeFileSync(outputPath, JSON.stringify(ast, null, 2));
@@ -53,7 +70,7 @@ export function toAstSync(inputPath: string, outputPath?: string) {
 export async function fromAst(inputPath: string, outputPath: string) {
 	console.log(`[BattleScript ${version}] fromAst: ${inputPath}`);
 	try {
-		const astString = await readFile(inputPath, "utf-8");
+		const astString = await sourceResolverAsync(inputPath);
 		const ast = JSON.parse(astString);
 		const code = fromFullAstToSourceCode(ast);
 		await writeFile(outputPath, code);
@@ -67,8 +84,12 @@ export async function fromAst(inputPath: string, outputPath: string) {
 export async function toMiniAst(inputPath: string, outputPath: string) {
 	console.log(`[BattleScript ${version}] toMiniAst: ${inputPath}`);
 	try {
-		const sourceCode = await readFile(inputPath, "utf-8");
-		const ast = fromSourceCodeToMiniAst(sourceCode, {filePath: inputPath, includeMetaData: true});
+		const sourceCode = await sourceResolverAsync(inputPath);
+		const ast = fromSourceCodeToMiniAst(sourceCode, {
+			filePath: inputPath,
+			includeMetaData: true,
+			sourceResolver: sourceResolverSync
+		});
 
 		await writeFile(outputPath, JSON.stringify(ast));
 		console.log(`[BattleScript ${version}] Compiled to ${outputPath}`);
@@ -82,10 +103,15 @@ export async function toBinary(inputPath: string, outputPath: string) {
 	console.log(`[BattleScript ${version}] toBinary: ${inputPath}`);
 	try {
 		console.log(`[BattleScript ${version}] Reading file contents: ${inputPath}`);
-		const sourceCode = await readFile(inputPath, "utf-8");
+		const sourceCode = await sourceResolverAsync(inputPath);
 
 		console.log(`[BattleScript ${version}] fromSourceCodeToBinary: ${inputPath}`);
-		const binary = fromSourceCodeToBinary(sourceCode, {includeMetaData: true, flatten: true, filePath: inputPath});
+		const binary = fromSourceCodeToBinary(sourceCode, {
+			includeMetaData: true,
+			flatten: true,
+			filePath: inputPath,
+			sourceResolver: sourceResolverSync
+		});
 
 		console.log(`[BattleScript ${version}] Writing file contents: ${outputPath}`);
 		await writeFile(outputPath, Buffer.concat(binary))
@@ -99,11 +125,12 @@ export async function toBinary(inputPath: string, outputPath: string) {
 
 export async function miniAstToBinary(inputPath: string, outputPath: string) {
 	try {
-		const sourceCode = await readFile(inputPath, "utf-8");
+		const sourceCode = await sourceResolverAsync(inputPath);
 		const binary = fromMiniAstToBinary(JSON.parse(sourceCode), {
 			includeMetaData: true,
 			flatten: true,
-			filePath: inputPath
+			filePath: inputPath,
+			sourceResolver: sourceResolverSync
 		});
 		await writeFile(outputPath, Buffer.concat(binary))
 
@@ -128,7 +155,7 @@ export async function fromBinary(inputPath: string, outputPath: string) {
 
 // async function toByteCode(inputPath: string, outputPath: string) {
 // 	try {
-// 		const sourceCode = await readFile(inputPath, "utf-8");
+// 		const sourceCode = await sourceResolverAsync(inputPath);
 // 		const bcodeJson = fromSourceCodeToByteCode(sourceCode, {includeMetaData: true, flatten: true});
 // 		await writeFile(outputPath, JSON.stringify(bcodeJson).replace(/\[\[/g, "[\n[").replace(/]]/g, "]\n]").replace(/],/g, "],\n"));
 // 		console.log(`Compiled to ${outputPath}`);
@@ -140,7 +167,7 @@ export async function fromBinary(inputPath: string, outputPath: string) {
 
 export async function fromByteCode(inputPath: string, outputPath: string) {
 	try {
-		const byteCodeJsonString = await readFile(inputPath, "utf-8");
+		const byteCodeJsonString = await sourceResolverAsync(inputPath);
 		const byteCodeJson: ByteCodeJson = JSON.parse(byteCodeJsonString);
 		const code = disassembleBytecode(byteCodeJson);
 		await writeFile(outputPath, code.join("\n"));

package/bin/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { readFile, writeFile } from 'fs/promises';
+import { writeFile, readFile } from 'fs/promises';
 import { join, dirname, basename, extname } from 'path';
 import require$$0 from 'assert';
 import require$$0$1 from 'util';
 import { readFileSync } from 'fs';
-import { writeFileSync } from 'node:fs';
+import 'node:fs';
 
 var ATNDeserializer = {};
 
@@ -26265,7 +26265,7 @@ var body$2 = [
 		kind: "FUNCTION_DECLARATION",
 		returnType: {
 			kind: "DATA_TYPE",
-			value: "float",
+			value: "void",
 			meta: {
 				start: {
 					line: 1,
@@ -26274,28 +26274,60 @@ var body$2 = [
 				},
 				stop: {
 					line: 1,
-					column: 12,
-					offset: 11
+					column: 11,
+					offset: 10
 				}
 			}
 		},
 		id: {
 			kind: "IDENTIFIER",
-			value: "std::gpio.readPin",
+			value: "std::gpio.setPinMode",
 			meta: {
 				start: {
 					line: 1,
-					column: 13,
-					offset: 13
+					column: 12,
+					offset: 12
 				},
 				stop: {
 					line: 1,
-					column: 30,
-					offset: 29
+					column: 32,
+					offset: 31
 				}
 			}
 		},
 		params: [
+			{
+				kind: "IDENTIFIER",
+				value: "newMode",
+				meta: {
+					start: {
+						line: 1,
+						column: 38,
+						offset: 38
+					},
+					stop: {
+						line: 1,
+						column: 45,
+						offset: 44
+					}
+				},
+				type: {
+					kind: "DATA_TYPE",
+					value: "int",
+					meta: {
+						start: {
+							line: 1,
+							column: 34,
+							offset: 34
+						},
+						stop: {
+							line: 1,
+							column: 37,
+							offset: 36
+						}
+					}
+				}
+			}
 		],
 		isNative: true,
 		isPure: false,
@@ -26307,8 +26339,8 @@ var body$2 = [
 			},
 			stop: {
 				line: 1,
-				column: 34,
-				offset: 33
+				column: 47,
+				offset: 46
 			}
 		}
 	},
@@ -26316,17 +26348,68 @@ var body$2 = [
 		kind: "FUNCTION_DECLARATION",
 		returnType: {
 			kind: "DATA_TYPE",
-			value: "void",
+			value: "float",
 			meta: {
 				start: {
 					line: 2,
 					column: 7,
-					offset: 42
+					offset: 55
 				},
 				stop: {
 					line: 2,
+					column: 12,
+					offset: 59
+				}
+			}
+		},
+		id: {
+			kind: "IDENTIFIER",
+			value: "std::gpio.readPin",
+			meta: {
+				start: {
+					line: 2,
+					column: 13,
+					offset: 61
+				},
+				stop: {
+					line: 2,
+					column: 30,
+					offset: 77
+				}
+			}
+		},
+		params: [
+		],
+		isNative: true,
+		isPure: false,
+		meta: {
+			start: {
+				line: 2,
+				column: 0,
+				offset: 48
+			},
+			stop: {
+				line: 2,
+				column: 34,
+				offset: 81
+			}
+		}
+	},
+	{
+		kind: "FUNCTION_DECLARATION",
+		returnType: {
+			kind: "DATA_TYPE",
+			value: "void",
+			meta: {
+				start: {
+					line: 3,
+					column: 7,
+					offset: 90
+				},
+				stop: {
+					line: 3,
 					column: 11,
-					offset: 45
+					offset: 93
 				}
 			}
 		},
@@ -26335,14 +26418,14 @@ var body$2 = [
 			value: "std::gpio.writePin",
 			meta: {
 				start: {
-					line: 2,
+					line: 3,
 					column: 12,
-					offset: 47
+					offset: 95
 				},
 				stop: {
-					line: 2,
+					line: 3,
 					column: 30,
-					offset: 64
+					offset: 112
 				}
 			}
 		},
@@ -26352,14 +26435,14 @@ var body$2 = [
 				value: "newVal",
 				meta: {
 					start: {
-						line: 2,
+						line: 3,
 						column: 36,
-						offset: 71
+						offset: 119
 					},
 					stop: {
-						line: 2,
+						line: 3,
 						column: 42,
-						offset: 76
+						offset: 124
 					}
 				},
 				type: {
@@ -26367,14 +26450,14 @@ var body$2 = [
 					value: "int",
 					meta: {
 						start: {
-							line: 2,
+							line: 3,
 							column: 32,
-							offset: 67
+							offset: 115
 						},
 						stop: {
-							line: 2,
+							line: 3,
 							column: 35,
-							offset: 69
+							offset: 117
 						}
 					}
 				}
@@ -26384,14 +26467,14 @@ var body$2 = [
 		isPure: false,
 		meta: {
 			start: {
-				line: 2,
+				line: 3,
 				column: 0,
-				offset: 35
+				offset: 83
 			},
 			stop: {
-				line: 2,
+				line: 3,
 				column: 44,
-				offset: 78
+				offset: 126
 			}
 		}
 	}
@@ -27902,7 +27985,7 @@ function getAllNativeLibraryFunctions(rootNode) {
     ];
 }
 
-var version = "3.1.5";
+var version = "3.1.7";
 var binaryVersion = 7;
 
 const RootNodeLayout = [{
@@ -27942,7 +28025,12 @@ const rootToAstNode = (instance, ctx) => {
         // Check we can locate the file
         console.log(`[BattleScript ${version}] Processing import compilation unit: `, importNode.source.value);
         const filePath = join(dirname(instance._filePath), importNode.source.value);
-        const importedAst = toAstSync(filePath);
+        const importedSourceCode = instance.resolveSourceCode(filePath);
+        const importedAst = fromSourceCodeToFullAst(importedSourceCode, {
+            filePath,
+            includeMetaData: true,
+            sourceResolver: instance._sourceResolver
+        });
         return importedAst.body;
     }).concat(standardLibraryDeclarations).filter((astNode) => {
         // TODO: We should move this to just before we complete the AST generation
@@ -28187,7 +28275,7 @@ function getMetaData(ctx, extra) {
     };
 }
 class BattleScriptToAST extends AbstractParseTreeVisitorExports.AbstractParseTreeVisitor {
-    constructor(filePath, sourceCode) {
+    constructor(filePath, sourceCode, sourceResolver) {
         super();
         this._options = {
             includeMetaData: true
@@ -28205,6 +28293,16 @@ class BattleScriptToAST extends AbstractParseTreeVisitorExports.AbstractParseTre
                 return;
             this._sourceCode = newSourceCode;
         };
+        this.resolveSourceCode = (filePath) => {
+            if (this._sourceResolver) {
+                const resolved = this._sourceResolver(filePath);
+                if (resolved !== undefined) {
+                    return resolved;
+                }
+                throw new Error(`Source resolver could not resolve source code for file: ${filePath}`);
+            }
+            throw new Error(`Could not resolve source code for file: ${filePath}. No source resolver provided.`);
+        };
         this.extractInlineComment = (ctx) => {
             if (!ctx)
                 return;
@@ -28434,6 +28532,7 @@ class BattleScriptToAST extends AbstractParseTreeVisitorExports.AbstractParseTre
         };
         this._filePath = filePath;
         this._sourceCode = sourceCode;
+        this._sourceResolver = sourceResolver;
     }
     visit(node, options) {
         if (options) {
@@ -28865,28 +28964,26 @@ class BattleScriptToMiniAST {
                     return requiredCount;
                 }, 0);
                 if (functionArgs.length < requiredCount) {
-                    functionParams.reduce((requiredCount, param, index) => {
-                        if (param.kind === "IDENTIFIER") {
-                            if (!functionArgs[index]) {
-                                throw new Error(formatCompilerError(this._filePath, this._sourceCode, "error", node.meta, `Call to function ${prettyPrintFunctionDeclaration(functionNode)} is missing required argument \`${this.nodeResolver.visit(param)}\``));
-                            }
-                            requiredCount++;
+                    functionParams.forEach((param, index) => {
+                        if (functionArgs[index]) {
                             finalArgs.push(functionArgs[index]);
+                            return;
+                        }
+                        if (param.kind === "IDENTIFIER") {
+                            throw new Error(formatCompilerError(this._filePath, this._sourceCode, "error", node.meta, `Call to function ${prettyPrintFunctionDeclaration(functionNode)} is missing required argument \`${this.nodeResolver.visit(param)}\``));
                         }
                         else if (param.kind === "ASSIGNMENT_PATTERN") {
-                            if (!functionArgs[index]) {
-                                // We don't have a value but we do have a default, use it
-                                // We use clone here because we want to create an entirely new node entry in the node array
-                                // just for this one argument so that we don't point at a node index (the default argument
-                                // in the function definition) because that would generate a non-contiguous start index
-                                // and count for the function call arguments. However, when the meta array is compiled,
-                                // the cloned node will still have the same meta data so will highlight the original
-                                // function definition parameter which shows where the value came from.
-                                finalArgs.push(clone(param.right));
-                            }
+                            // We don't have a value but we do have a default, use it
+                            // We use clone here because we want to create an entirely new node entry in the node array
+                            // just for this one argument so that we don't point at a node index (the default argument
+                            // in the function definition) because that would generate a non-contiguous start index
+                            // and count for the function call arguments. However, when the meta array is compiled,
+                            // the cloned node will still have the same meta data so will highlight the original
+                            // function definition parameter which shows where the value came from.
+                            finalArgs.push(clone(param.right));
                         }
-                        return requiredCount;
-                    }, 0);
+                        return;
+                    });
                 }
                 else {
                     return functionArgs;
@@ -38796,9 +38893,7 @@ function fromSourceCodeToFullAst(inputText, options) {
     const parser = getParser(inputText);
     const tree = parser.root();
     console.log(`[BattleScript ${version}] Transforming source code -> AST...`);
-    const transformer = new BattleScriptToAST(options?.filePath || "-", inputText);
-    transformer.filePath(options?.filePath);
-    transformer.sourceCode(inputText);
+    const transformer = new BattleScriptToAST(options?.filePath || "-", inputText, options?.sourceResolver);
     return transformer.visit(tree, options);
 }
 function fromFullAstToSourceCode(ast, options = { includeMetaData: true }) {
@@ -38810,8 +38905,6 @@ function fromSourceCodeToMiniAst(source, options = { includeMetaData: true }) {
     const ast = fromSourceCodeToFullAst(source, options);
     console.log(`[BattleScript ${version}] Transforming AST -> MiniAST...`);
     const transformer = new BattleScriptToMiniAST(options?.filePath || "-", source);
-    transformer.filePath(options?.filePath);
-    transformer.sourceCode(source); // Add for debugging purposes
     return transformer.transform(ast, options);
 }
 function fromMiniAstToBinary(miniAst, options = { includeMetaData: true }) {
@@ -38913,11 +39006,21 @@ function disassembleBytecode([stringTable, bytecode]) {
     return output;
 }
 
+const sourceResolverAsync = (filePath) => {
+    return readFile(filePath, "utf-8");
+};
+const sourceResolverSync = (filePath) => {
+    return readFileSync(filePath, "utf-8");
+};
 async function toAst(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] toAst: ${inputPath}`);
     try {
-        const sourceCode = await readFile(inputPath, "utf-8");
-        const ast = fromSourceCodeToFullAst(sourceCode, { filePath: inputPath, includeMetaData: true });
+        const sourceCode = await sourceResolverAsync(inputPath);
+        const ast = fromSourceCodeToFullAst(sourceCode, {
+            filePath: inputPath,
+            includeMetaData: true,
+            sourceResolver: sourceResolverSync
+        });
         if (outputPath) {
             await writeFile(outputPath, JSON.stringify(ast, null, 2));
             console.log(`[BattleScript ${version}] Compiled to ${outputPath}`);
@@ -38931,25 +39034,10 @@ async function toAst(inputPath, outputPath) {
         process.exit(1);
     }
 }
-function toAstSync(inputPath, outputPath) {
-    console.log(`[BattleScript ${version}] toAstSync: ${inputPath}`);
-    try {
-        const sourceCode = readFileSync(inputPath, "utf-8");
-        const ast = fromSourceCodeToFullAst(sourceCode, { filePath: inputPath, includeMetaData: true });
-        if (outputPath) ;
-        else {
-            return ast;
-        }
-    }
-    catch (error) {
-        console.error(`[BattleScript ${version}] Error:`, error.stack);
-        process.exit(1);
-    }
-}
 async function fromAst(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] fromAst: ${inputPath}`);
     try {
-        const astString = await readFile(inputPath, "utf-8");
+        const astString = await sourceResolverAsync(inputPath);
         const ast = JSON.parse(astString);
         const code = fromFullAstToSourceCode(ast);
         await writeFile(outputPath, code);
@@ -38963,8 +39051,12 @@ async function fromAst(inputPath, outputPath) {
 async function toMiniAst(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] toMiniAst: ${inputPath}`);
     try {
-        const sourceCode = await readFile(inputPath, "utf-8");
-        const ast = fromSourceCodeToMiniAst(sourceCode, { filePath: inputPath, includeMetaData: true });
+        const sourceCode = await sourceResolverAsync(inputPath);
+        const ast = fromSourceCodeToMiniAst(sourceCode, {
+            filePath: inputPath,
+            includeMetaData: true,
+            sourceResolver: sourceResolverSync
+        });
         await writeFile(outputPath, JSON.stringify(ast));
         console.log(`[BattleScript ${version}] Compiled to ${outputPath}`);
     }
@@ -38977,9 +39069,14 @@ async function toBinary(inputPath, outputPath) {
     console.log(`[BattleScript ${version}] toBinary: ${inputPath}`);
     try {
         console.log(`[BattleScript ${version}] Reading file contents: ${inputPath}`);
-        const sourceCode = await readFile(inputPath, "utf-8");
+        const sourceCode = await sourceResolverAsync(inputPath);
         console.log(`[BattleScript ${version}] fromSourceCodeToBinary: ${inputPath}`);
-        const binary = fromSourceCodeToBinary(sourceCode, { includeMetaData: true, flatten: true, filePath: inputPath });
+        const binary = fromSourceCodeToBinary(sourceCode, {
+            includeMetaData: true,
+            flatten: true,
+            filePath: inputPath,
+            sourceResolver: sourceResolverSync
+        });
         console.log(`[BattleScript ${version}] Writing file contents: ${outputPath}`);
         await writeFile(outputPath, Buffer.concat(binary));
         console.log(`[BattleScript ${version}] Compiled to ${outputPath}`);
@@ -38991,11 +39088,12 @@ async function toBinary(inputPath, outputPath) {
 }
 async function miniAstToBinary(inputPath, outputPath) {
     try {
-        const sourceCode = await readFile(inputPath, "utf-8");
+        const sourceCode = await sourceResolverAsync(inputPath);
         const binary = fromMiniAstToBinary(JSON.parse(sourceCode), {
             includeMetaData: true,
             flatten: true,
-            filePath: inputPath
+            filePath: inputPath,
+            sourceResolver: sourceResolverSync
         });
         await writeFile(outputPath, Buffer.concat(binary));
         console.log(`[BattleScript ${version}] Compiled to ${outputPath}`);
@@ -39019,7 +39117,7 @@ async function fromBinary(inputPath, outputPath) {
 }
 // async function toByteCode(inputPath: string, outputPath: string) {
 // 	try {
-// 		const sourceCode = await readFile(inputPath, "utf-8");
+// 		const sourceCode = await sourceResolverAsync(inputPath);
 // 		const bcodeJson = fromSourceCodeToByteCode(sourceCode, {includeMetaData: true, flatten: true});
 // 		await writeFile(outputPath, JSON.stringify(bcodeJson).replace(/\[\[/g, "[\n[").replace(/]]/g, "]\n]").replace(/],/g, "],\n"));
 // 		console.log(`Compiled to ${outputPath}`);
@@ -39030,7 +39128,7 @@ async function fromBinary(inputPath, outputPath) {
 // }
 async function fromByteCode(inputPath, outputPath) {
     try {
-        const byteCodeJsonString = await readFile(inputPath, "utf-8");
+        const byteCodeJsonString = await sourceResolverAsync(inputPath);
         const byteCodeJson = JSON.parse(byteCodeJsonString);
         const code = disassembleBytecode(byteCodeJson);
         await writeFile(outputPath, code.join("\n"));