182 lines
8.1 KiB
JavaScript
182 lines
8.1 KiB
JavaScript
"use strict";
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (this && this.__importStar) || (function () {
|
|
var ownKeys = function(o) {
|
|
ownKeys = Object.getOwnPropertyNames || function (o) {
|
|
var ar = [];
|
|
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
|
return ar;
|
|
};
|
|
return ownKeys(o);
|
|
};
|
|
return function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.activate = activate;
|
|
exports.deactivate = deactivate;
|
|
const vscode = __importStar(require("vscode"));
|
|
const cp = __importStar(require("child_process"));
|
|
const fs = __importStar(require("fs"));
|
|
const path = __importStar(require("path"));
|
|
const os = __importStar(require("os"));
|
|
const codelensProvider_1 = require("./codelensProvider");
|
|
function getConfig(key, def) { const v = vscode.workspace.getConfiguration().get(key); return v === undefined ? def : v; }
|
|
function getWorkspaceFolderUri(docUri) { return docUri ? vscode.workspace.getWorkspaceFolder(docUri)?.uri : vscode.workspace.workspaceFolders?.[0]?.uri; }
|
|
function readPackageName(text) { return text.match(/^\s*package\s+([\w\.]+)\s*;/m)?.[1]; }
|
|
function fqcnFromDocument(doc) { const pkg = readPackageName(doc.getText()); const simple = path.basename(doc.fileName).replace(/\.java$/i, ""); return pkg ? `${pkg}.${simple}` : simple; }
|
|
function execInTerminal(cmd, cwd, name = "Java Class Runner") { const t = vscode.window.terminals.find(tt => tt.name === name) || vscode.window.createTerminal({ name }); t.show(true); if (cwd)
|
|
t.sendText(`cd "${cwd}"`); t.sendText(cmd); }
|
|
let homeDirectory;
|
|
let currentUser;
|
|
function untildify(pathWithTilde) {
|
|
if (homeDirectory === undefined) {
|
|
homeDirectory = os.homedir();
|
|
}
|
|
// Handle regular ~ expansion (current user)
|
|
if (homeDirectory && /^~(?=$|\/|\\)/.test(pathWithTilde)) {
|
|
return pathWithTilde.replace(/^~/, homeDirectory);
|
|
}
|
|
// Handle ~username expansion (only for current user)
|
|
const userMatch = pathWithTilde.match(/^~([^/\\]+)(.*)/);
|
|
if (userMatch) {
|
|
if (currentUser === undefined) {
|
|
currentUser = os.userInfo().username;
|
|
}
|
|
if (currentUser) {
|
|
const username = userMatch[1];
|
|
const rest = userMatch[2];
|
|
if (username === currentUser) {
|
|
return homeDirectory + rest;
|
|
}
|
|
}
|
|
}
|
|
// Return unchanged if no expansion occurred
|
|
return pathWithTilde;
|
|
}
|
|
async function ensureDir(p) {
|
|
await fs.promises.mkdir(p, { recursive: true });
|
|
}
|
|
async function compileJava(javaFile, outDir, classpath, ctxpath, wd) {
|
|
await ensureDir(outDir);
|
|
if (javaFile.includes(".java")) {
|
|
return new Promise((resolve, reject) => {
|
|
const args = [javaFile, "-cp", classpath, "-d", outDir];
|
|
const proc = cp.spawn("javac", args, { shell: process.platform === "win32" });
|
|
let stderr = "";
|
|
proc.stderr.on("data", d => stderr += d.toString());
|
|
proc.on("close", code => code === 0 ? resolve() : reject(new Error(`javac exit code ${code}\n${stderr}`)));
|
|
});
|
|
}
|
|
vscode.window.showInformationMessage("Compiling with Java-TX");
|
|
return new Promise((resolve, reject) => {
|
|
const config = vscode.workspace.getConfiguration("tx");
|
|
let compiler = config.get("compilerLocation");
|
|
if (!compiler || compiler.trim() === "") {
|
|
vscode.window.showErrorMessage("Bitte konfiguriere den Pfad des Java-TX Compilers in den Einstellungen!");
|
|
return null;
|
|
}
|
|
compiler = path.resolve(untildify(compiler));
|
|
const args = [
|
|
"-jar", compiler, javaFile,
|
|
"-cp", classpath,
|
|
"-d", outDir,
|
|
];
|
|
console.log("spawn args:", args.map(a => JSON.stringify(a)).join(" "));
|
|
const proc = cp.spawn("java", args, {
|
|
cwd: wd,
|
|
env: { ...process.env },
|
|
shell: false,
|
|
});
|
|
proc.stdout.on("data", d => console.log(`[java stdout] ${d}`));
|
|
proc.stderr.on("data", d => console.error(`[java stderr] ${d}`));
|
|
proc.on("close", code => code === 0 ? resolve() : reject(new Error(`javac exit code ${code}}`)));
|
|
});
|
|
}
|
|
function activate(ctx) {
|
|
ctx.subscriptions.push(vscode.languages.registerCodeLensProvider([{ language: "java" }, { pattern: "**/*.jav" }], new codelensProvider_1.JavaMainCodeLensProvider()));
|
|
ctx.subscriptions.push(vscode.commands.registerCommand("javaClassRunner.runMain", async () => {
|
|
const ed = vscode.window.activeTextEditor;
|
|
if (!ed || ed.document.languageId !== "java") {
|
|
vscode.window.showErrorMessage("Öffne eine Java-Datei mit main(...)");
|
|
return;
|
|
}
|
|
const ws = getWorkspaceFolderUri(ed.document.uri);
|
|
const fileDir = path.dirname(ed.document.fileName);
|
|
const outDir = path.join(fileDir, "out", "main");
|
|
const cpFolders = [outDir, path.join(fileDir, "out")];
|
|
ensureDir(outDir);
|
|
if (fs.existsSync(outDir)) {
|
|
for (const entry of fs.readdirSync(outDir)) {
|
|
const fullPath = path.join(outDir, entry);
|
|
if (fs.lstatSync(fullPath).isDirectory()) {
|
|
fs.rmSync(fullPath, { recursive: true, force: true });
|
|
}
|
|
else {
|
|
fs.unlinkSync(fullPath);
|
|
}
|
|
}
|
|
}
|
|
const wdCfg = getConfig("javaClassRunner.run.workingDirectory", "${workspaceFolder}");
|
|
const wd = wdCfg.replace("${workspaceFolder}", ws?.fsPath ?? process.cwd());
|
|
const fqcn = fqcnFromDocument(ed.document);
|
|
if (!fqcn) {
|
|
vscode.window.showErrorMessage("Konnte FQCN nicht bestimmen.");
|
|
return;
|
|
}
|
|
try {
|
|
await compileJava(ed.document.fileName, outDir, cpFolders.join(path.delimiter), ctx.extensionPath, wd);
|
|
}
|
|
catch (err) {
|
|
vscode.window.showErrorMessage(`Kompilierung fehlgeschlagen: ${err?.message || String(err)}`);
|
|
return;
|
|
}
|
|
// Find the first .class file in outDir (excluding inner classes with $)
|
|
let mainClass;
|
|
const walk = (dir) => {
|
|
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
|
for (const e of entries) {
|
|
const full = path.join(dir, e.name);
|
|
if (e.isDirectory())
|
|
walk(full);
|
|
else if (e.isFile() && e.name.endsWith(".class") && !e.name.includes("$") && !mainClass) {
|
|
const rel = path.relative(outDir, full).replace(/\.class$/, "");
|
|
mainClass = rel.split(path.sep).join(".");
|
|
}
|
|
if (mainClass)
|
|
break;
|
|
}
|
|
};
|
|
if (fs.existsSync(outDir))
|
|
walk(outDir);
|
|
if (!mainClass) {
|
|
vscode.window.showErrorMessage("Keine .class-Datei im Ausgabeverzeichnis gefunden.");
|
|
return;
|
|
}
|
|
const cmd = `java -cp "${cpFolders.join(path.delimiter)}" ${mainClass}`.trim();
|
|
vscode.window.showInformationMessage(cmd);
|
|
execInTerminal(cmd, wd);
|
|
}));
|
|
}
|
|
function deactivate() { }
|
|
//# sourceMappingURL=extension.js.map
|