dutchie031
ed48c4d2de
publish-vs-code-extensions.yml / Publish VS Code Extension (push) Successful in 29s
420 lines
15 KiB
TypeScript
420 lines
15 KiB
TypeScript
import * as fs from 'fs';
|
|
import * as path from 'path';
|
|
import { LuaFile, BlockType, CodeBlock, RequireBlock, ReturnBlock, FunctionBlock, TableBlock } from './CodeBlocks';
|
|
import { CompilationError } from './CompilationError';
|
|
|
|
export interface ScriptCompilerOptions {
|
|
sourcePath: string,
|
|
outputPath: string,
|
|
outputFileName?: string,
|
|
minify: boolean,
|
|
onError?: (error: CompilationError) => void
|
|
}
|
|
|
|
export interface ICompilationLogger {
|
|
info(message: string): void;
|
|
error(message: string): void;
|
|
writeLine(message: string): void;
|
|
}
|
|
|
|
export { CompilationError };
|
|
|
|
class Metrics {
|
|
public totalLinesRead : number = 0;
|
|
public totalLinesWritten: number = 0;
|
|
public readTimeMs : number = 0;
|
|
public writeTimeMs : number = 0;
|
|
public totalTimeMs : number = 0;
|
|
public filesRead : number = 0;
|
|
public filesWritten : number = 0;
|
|
|
|
log(logger: ICompilationLogger){
|
|
logger.writeLine("Compilation Metrics: ")
|
|
logger.writeLine(`=====================`)
|
|
logger.writeLine(`Lines Read: ${this.totalLinesRead}`)
|
|
logger.writeLine(`Lines Written: ${this.totalLinesWritten}`)
|
|
logger.writeLine(`Files Processed: ${this.filesRead} | ${this.filesWritten}`)
|
|
logger.writeLine(`=====================`)
|
|
logger.writeLine(`Read Time (ms): ${this.readTimeMs} ms`)
|
|
logger.writeLine(`Write Time (ms): ${this.writeTimeMs} ms`)
|
|
logger.writeLine(`Total Time (ms): ${this.totalTimeMs} ms`)
|
|
}
|
|
}
|
|
|
|
const LUA_SCRIPT_GLOBAL_KEYWORD = 'ScriptGlobals';
|
|
|
|
export class ScriptCompiler {
|
|
|
|
constructor(private options: ScriptCompilerOptions, private logger: ICompilationLogger) {
|
|
if (options.outputFileName === undefined) {
|
|
this.options.outputFileName = 'compiled.lua';
|
|
}
|
|
}
|
|
|
|
public async compile(includeDevScript: boolean): Promise<void> {
|
|
const start = Date.now();
|
|
const metricsMeter = new Metrics();
|
|
const entries = fs.readdirSync(this.options.sourcePath, { recursive: true, withFileTypes: true });
|
|
const parsedFiles: Map<string, ParsedFile> = new Map();
|
|
|
|
const readStart = Date.now();
|
|
for (const entry of entries) {
|
|
if (entry.isFile() && entry.name.endsWith('.lua')) {
|
|
const fullPath = path.join(entry.parentPath, entry.name);
|
|
const relativePath = path.relative(this.options.sourcePath, fullPath);
|
|
const luaFile = LuaFile.createFromFile(fullPath, this.options.onError);
|
|
const luaReference = fileReferenceToLuaVariable(relativePath);
|
|
const key = luaReference.replace(LUA_SCRIPT_GLOBAL_KEYWORD + '.', '').toLowerCase();
|
|
|
|
if(parsedFiles.has(key)){
|
|
this.options.onError?.({
|
|
filePath: fullPath,
|
|
line: 0,
|
|
message: `Duplicate file key detected: ${key}. This can happen if two files have different capitalization. Lua is case sensitive, but the compiler treats file keys as case insensitive.`
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const parsedFile = new ParsedFile(key, luaFile, fullPath);
|
|
|
|
parsedFiles.set(parsedFile.fileKey, parsedFile);
|
|
metricsMeter.filesRead++;
|
|
}
|
|
}
|
|
const readEnd = Date.now();
|
|
metricsMeter.readTimeMs = readEnd - readStart;
|
|
|
|
const writer = new Writer(
|
|
path.join(this.options.outputPath, this.options.outputFileName!),
|
|
parsedFiles,
|
|
this.logger,
|
|
this.options.onError
|
|
);
|
|
|
|
writer.logDependencyTree();
|
|
|
|
const writeStart = Date.now();
|
|
writer.write(includeDevScript, metricsMeter);
|
|
const writeEnd = Date.now();
|
|
metricsMeter.writeTimeMs = (writeEnd - writeStart);
|
|
|
|
// writer.logDependencyTree();
|
|
this.logger.info(`Compilation complete. Output written to ${path.join(this.options.outputPath, this.options.outputFileName!)}`);
|
|
const end = Date.now();
|
|
|
|
metricsMeter.totalTimeMs = (end-start);
|
|
metricsMeter.log(this.logger);
|
|
}
|
|
}
|
|
|
|
class Dependency {
|
|
public readonly fileKey: string;
|
|
public readonly luaReference: string;
|
|
|
|
constructor(
|
|
public readonly requiredModule: string,
|
|
public readonly requiredAtLine: number,
|
|
public readonly charStart: number,
|
|
public readonly charEnd: number
|
|
)
|
|
{
|
|
this.luaReference = fileReferenceToLuaVariable(requiredModule);
|
|
this.fileKey = this.luaReference.replace(LUA_SCRIPT_GLOBAL_KEYWORD + '.', '').toLowerCase();
|
|
}
|
|
}
|
|
|
|
|
|
function fileReferenceToLuaVariable(fileReference: string): string {
|
|
// Remove .lua extension
|
|
if (fileReference.endsWith('.lua')) {
|
|
fileReference = fileReference.substring(0, fileReference.length - 4);
|
|
}
|
|
|
|
// Remove leading ./
|
|
if (fileReference.startsWith('./')) {
|
|
fileReference = fileReference.substring(2);
|
|
}
|
|
|
|
// Normalize path separators
|
|
fileReference = fileReference.replace(/\\/g, '/').replace(/\./g, '/');
|
|
|
|
// Split by / to get path parts
|
|
const parts = fileReference.split('/');
|
|
|
|
// Convert to ScriptGlobals.folder.FileName format
|
|
let result = LUA_SCRIPT_GLOBAL_KEYWORD;
|
|
for (let i = 0; i < parts.length; i++) {
|
|
result += '.' + parts[i].toLowerCase();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
class ParsedFile {
|
|
public readonly dependencies: Dependency[] = []
|
|
|
|
constructor(
|
|
public readonly fileKey: string,
|
|
public readonly luaFile: LuaFile,
|
|
public readonly fullPath: string
|
|
){
|
|
this.dependencies = ParsedFile.parseDependencies(luaFile);
|
|
}
|
|
|
|
private static parseDependencies(luaFile: CodeBlock): Dependency[] {
|
|
// Recursively search for RequireBlocks in the LuaFile and its child blocks
|
|
const dependencies: Dependency[] = [];
|
|
const searchBlock = (block: CodeBlock) => {
|
|
if (block instanceof RequireBlock) {
|
|
const requiredString = block.getRequiredString();
|
|
if (requiredString) {
|
|
dependencies.push(new Dependency(requiredString.toLowerCase(), block.sourceLineNumber ?? 0, block.charStart ?? 0, block.charEnd ?? 0));
|
|
}
|
|
}
|
|
|
|
for (const child of block.getChildren()) {
|
|
searchBlock(child);
|
|
}
|
|
}
|
|
searchBlock(luaFile);
|
|
return dependencies;
|
|
}
|
|
|
|
public replaceRequireWithGlobal(): void {
|
|
|
|
function replaceRequireInBlock(block: CodeBlock) {
|
|
|
|
if (block instanceof RequireBlock) {
|
|
const requiredString = block.getRequiredString();
|
|
if (requiredString) {
|
|
const luaReference = fileReferenceToLuaVariable(requiredString);
|
|
block.toLines = () => [`${luaReference}\n`];
|
|
}
|
|
}
|
|
|
|
for (const child of block.getChildren()) {
|
|
replaceRequireInBlock(child);
|
|
}
|
|
}
|
|
|
|
for (const child of this.luaFile.getChildren()) {
|
|
replaceRequireInBlock(child);
|
|
}
|
|
|
|
}
|
|
|
|
public replaceModuleReturnWithGlobalAssignement(): void {
|
|
|
|
const replaceReturnInBlock = (block: CodeBlock) => {
|
|
if (block instanceof ReturnBlock) {
|
|
const parent = block.getParentBlock();
|
|
if (parent) {
|
|
const luaReference = fileReferenceToLuaVariable(this.fileKey);
|
|
const resultLines : string[] = [];
|
|
|
|
const splitCount = luaReference.split('.').length;
|
|
for(let i = 2; i <= splitCount -1 ; i++){
|
|
const partialReference = luaReference.split('.').slice(0, i).join('.');
|
|
resultLines.push(`if not ${partialReference} then ${partialReference} = {} end`);
|
|
}
|
|
|
|
resultLines.push(`${luaReference} = ${block.returnParams.join(', ')}`);
|
|
block.toLines = () => resultLines.map(line => line + '\n');
|
|
}
|
|
}
|
|
|
|
if(block instanceof FunctionBlock || block instanceof TableBlock){
|
|
return; // Do not traverse into FunctionBlock or TableBlock
|
|
}
|
|
|
|
for (const child of block.getChildren()) {
|
|
replaceReturnInBlock(child);
|
|
}
|
|
}
|
|
|
|
for (const child of this.luaFile.getChildren()) {
|
|
replaceReturnInBlock(child);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
class Writer {
|
|
constructor(
|
|
public location: string,
|
|
public files: Map<string, ParsedFile>,
|
|
private readonly logger: ICompilationLogger,
|
|
public onError?: (error: CompilationError) => void
|
|
) {}
|
|
|
|
private getStartLines(): string[] {
|
|
return [
|
|
`-- Transpiled at (UTC): ${new Date().toISOString()}\n`,
|
|
`local ${LUA_SCRIPT_GLOBAL_KEYWORD} = {}\n`
|
|
];
|
|
}
|
|
|
|
logDependencyTree(): void {
|
|
const visited: Set<string> = new Set();
|
|
const depth : number = 1;
|
|
this.logger.writeLine('Dependency Tree <root>:');
|
|
const logFileRecursive = (parsedFile: ParsedFile, currentDepth: number) => {
|
|
if(currentDepth === 0 && visited.has(parsedFile.fileKey)) {
|
|
return;
|
|
}
|
|
|
|
visited.add(parsedFile.fileKey);
|
|
let padding = ' '.repeat(currentDepth * 2);
|
|
if (currentDepth > 0) {
|
|
padding += '└─>';
|
|
}
|
|
|
|
const printable = parsedFile.fileKey.replace(LUA_SCRIPT_GLOBAL_KEYWORD + '.', '');
|
|
const lastPart = printable.split('.').pop();
|
|
this.logger.writeLine(`${padding} ${lastPart} ${' '.repeat(Math.max(0, 64 - padding.length - (lastPart ? lastPart.length : 0)))} ${printable}`);
|
|
for (const dep of parsedFile.dependencies) {
|
|
const depFile = this.files.get(dep.fileKey);
|
|
if (depFile) {
|
|
logFileRecursive(depFile, currentDepth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const parsedFile of this.files.values()) {
|
|
logFileRecursive(parsedFile, depth);
|
|
}
|
|
};
|
|
|
|
write(includeDevScript: boolean, metrics: Metrics): void {
|
|
const writtenFiles: Set<string> = new Set();
|
|
const outputLines: string[] = [];
|
|
|
|
const startLines = this.getStartLines();
|
|
metrics.totalLinesWritten+=startLines.length;
|
|
outputLines.push(...startLines);
|
|
|
|
//Check for circular dependencies before writing
|
|
const visited: Set<string> = new Set();
|
|
for (const fileKey of this.files.keys()) {
|
|
const stack: string[] = [];
|
|
const checkCircular = (key: string): boolean => {
|
|
if (stack.includes(key)) {
|
|
const cycleStart = stack.indexOf(key);
|
|
const cycle = [...stack.slice(cycleStart), key];
|
|
const file = this.files.get(stack[stack.length - 1]);
|
|
if (file && this.onError) {
|
|
this.onError({
|
|
filePath: file.fullPath,
|
|
line: 0,
|
|
message: `Circular dependency detected: ${cycle.map(x => x.split('.').pop()).join(' -> ')}`
|
|
});
|
|
}
|
|
return true;
|
|
}
|
|
if (visited.has(key)) {
|
|
return false;
|
|
}
|
|
visited.add(key);
|
|
stack.push(key);
|
|
const file = this.files.get(key);
|
|
if (file) {
|
|
for (const dep of file.dependencies) {
|
|
if (checkCircular(dep.fileKey)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
stack.pop();
|
|
return false;
|
|
};
|
|
|
|
if (checkCircular(fileKey)) {
|
|
throw new Error(`Compilation failed due to circular dependencies`);
|
|
}
|
|
}
|
|
|
|
const writeFileRecursive = (parsedFile: ParsedFile) => {
|
|
if (writtenFiles.has(parsedFile.fileKey)) {
|
|
return;
|
|
}
|
|
|
|
// Write dependencies first
|
|
for (const dep of parsedFile.dependencies) {
|
|
const depFile = this.files.get(dep.fileKey);
|
|
if (depFile) {
|
|
writeFileRecursive(depFile);
|
|
} else {
|
|
this.onError?.({
|
|
filePath: parsedFile.fullPath,
|
|
line: dep.requiredAtLine,
|
|
charStart: dep.charStart,
|
|
charEnd: dep.charEnd,
|
|
message: `Missing dependency: ${dep.fileKey}`
|
|
});
|
|
}
|
|
}
|
|
|
|
parsedFile.replaceRequireWithGlobal();
|
|
parsedFile.replaceModuleReturnWithGlobalAssignement();
|
|
|
|
const lines = parsedFile.luaFile.toLines();
|
|
const newLineFilteredLines : string[] = [];
|
|
|
|
function trimEndPreserveNewlines(str: string): string {
|
|
return str.replace(/[ \t]+$/gm, '');
|
|
}
|
|
|
|
|
|
let wasLastEmpty = false;
|
|
let lastEndedWithNewline = false;
|
|
for(const line of lines){
|
|
if(trimEndPreserveNewlines(line) !== ''){
|
|
if(line.trim() === ''){
|
|
if(!wasLastEmpty && !lastEndedWithNewline){
|
|
newLineFilteredLines.push(line);
|
|
wasLastEmpty = true;
|
|
}
|
|
} else {
|
|
newLineFilteredLines.push(line);
|
|
wasLastEmpty = false;
|
|
|
|
lastEndedWithNewline = line.endsWith('\n');
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
outputLines.push("do -- " + parsedFile.fileKey + "\n");
|
|
|
|
metrics.totalLinesWritten += newLineFilteredLines.length;
|
|
outputLines.push(...newLineFilteredLines);
|
|
outputLines.push("\nend -- " + parsedFile.fileKey + "\n");
|
|
writtenFiles.add(parsedFile.fileKey);
|
|
metrics.filesWritten++;
|
|
};
|
|
|
|
// Write all files in dependency order
|
|
for (const parsedFile of this.files.values()) {
|
|
writeFileRecursive(parsedFile);
|
|
}
|
|
|
|
fs.mkdirSync(path.dirname(this.location), { recursive: true });
|
|
fs.writeFileSync(this.location, outputLines.join(''), 'utf-8');
|
|
|
|
if(includeDevScript) {
|
|
const devFileLocation = this.location.replace('.lua', '.dev.lua');
|
|
this.writeDevScript(devFileLocation, this.location);
|
|
}
|
|
}
|
|
|
|
private writeDevScript(devFileLocation: string, actualFileLocation: string){
|
|
const devLines = [
|
|
`-- DEV SCRIPT - NOT FOR PRODUCTION USE`,
|
|
`-- This script can be referenced in DCS. Compiled script will then be loaded dynamically.`,
|
|
`-- This way you can test the compiled output without having to re-import the script into the mission every time.`,
|
|
`-- This file will only have to be re-imported when the name or location of the compiled script file changes.`,
|
|
`assert(loadfile([[${actualFileLocation}]]))()`
|
|
];
|
|
fs.writeFileSync(devFileLocation, devLines.join('\n'), 'utf-8');
|
|
this.logger.info(`Development script written to ${devFileLocation}`);
|
|
}
|
|
} |