blob: 3d4ef81ebbeec67a38d148cdb820801d08394faa [file] [log] [blame] [raw]
// Copyright (c) 2017, Compiler Explorer Authors
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
import path from 'path';
import fs from 'fs-extra';
import {ExecutionOptions} from '../../types/compilation/compilation.interfaces';
import {CompilerInfo} from '../../types/compiler.interfaces';
import {ParseFiltersAndOutputOptions} from '../../types/features/filters.interfaces';
import {unwrap} from '../assert';
import {BaseCompiler} from '../base-compiler';
import {MapFileReaderDelphi} from '../mapfiles/map-file-delphi';
import {PELabelReconstructor} from '../pe32-support';
import * as utils from '../utils';
import {PascalUtils} from './pascal-utils';
export class PascalWinCompiler extends BaseCompiler {
static get key() {
return 'pascal-win';
}
mapFilename: string | null;
dprFilename: string;
pasUtils: PascalUtils;
constructor(info: CompilerInfo, env) {
super(info, env);
info.supportsFiltersInBinary = true;
this.mapFilename = null;
this.compileFilename = 'output.pas';
this.dprFilename = 'prog.dpr';
this.pasUtils = new PascalUtils();
}
override getSharedLibraryPathsAsArguments() {
return [];
}
override exec(command: string, args: string[], options: ExecutionOptions) {
if (process.platform === 'linux' || process.platform === 'darwin') {
const wine = this.env.ceProps<string>('wine');
args = args.slice(0);
if (command.toLowerCase().endsWith('.exe')) {
args.unshift(command);
command = wine;
}
}
return super.exec(command, args, options);
}
override getExecutableFilename(dirPath: string) {
return path.join(dirPath, 'prog.exe');
}
override getOutputFilename(dirPath: string) {
return path.join(dirPath, 'prog.exe');
}
override filename(fn) {
if (process.platform === 'linux' || process.platform === 'darwin') {
return 'Z:' + fn;
} else {
return super.filename(fn);
}
}
override async objdump(outputFilename, result, maxSize: number, intelAsm) {
const dirPath = path.dirname(outputFilename);
const execBinary = this.getExecutableFilename(dirPath);
if (await utils.fileExists(execBinary)) {
outputFilename = execBinary;
} else {
outputFilename = this.getOutputFilename(path.dirname(outputFilename));
}
let args = ['-d', outputFilename];
if (intelAsm) args = args.concat(['-M', 'intel']);
return this.exec(this.compiler.objdumper, args, {maxOutput: 1024 * 1024 * 1024}).then(objResult => {
if (objResult.code === 0) {
result.asm = objResult.stdout;
} else {
result.asm = '<No output: objdump returned ' + objResult.code + '>';
}
return result;
});
}
async saveDummyProjectFile(filename: string, unitName: string, unitPath: string) {
await fs.writeFile(
filename,
// prettier-ignore
'program prog;\n' +
'uses ' + unitName + ' in \'' + unitPath + '\';\n' +
'begin\n' +
'end.\n',
);
}
override async writeAllFiles(dirPath: string, source: string, files: any[], filters: ParseFiltersAndOutputOptions) {
let inputFilename;
if (this.pasUtils.isProgram(source)) {
inputFilename = path.join(dirPath, this.dprFilename);
} else {
const unitName = this.pasUtils.getUnitname(source);
if (unitName) {
inputFilename = path.join(dirPath, unitName + '.pas');
} else {
inputFilename = path.join(dirPath, this.compileFilename);
}
}
await fs.writeFile(inputFilename, source);
if (files && files.length > 0) {
await this.writeMultipleFiles(files, dirPath);
}
return {
inputFilename,
};
}
override async runCompiler(
compiler: string,
options: string[],
inputFilename: string,
execOptions: ExecutionOptions,
) {
if (!execOptions) {
execOptions = this.getDefaultExecOptions();
}
const alreadyHasDPR = path.basename(inputFilename) === this.dprFilename;
const tempPath = path.dirname(inputFilename);
const projectFile = path.join(tempPath, this.dprFilename);
this.mapFilename = path.join(tempPath, 'prog.map');
inputFilename = inputFilename.replace(/\//g, '\\');
if (!alreadyHasDPR) {
const unitFilepath = path.basename(inputFilename);
const unitName = unitFilepath.replace(/.pas$/i, '');
await this.saveDummyProjectFile(projectFile, unitName, unitFilepath);
}
options.pop();
options.unshift('-CC', '-W', '-H', '-GD', '-$D+', '-V', '-B');
options.push(projectFile);
execOptions.customCwd = tempPath;
return this.exec(compiler, options, execOptions).then(result => {
return {
...result,
inputFilename,
stdout: utils.parseOutput(result.stdout, inputFilename),
stderr: utils.parseOutput(result.stderr, inputFilename),
};
});
}
override optionsForFilter(filters: ParseFiltersAndOutputOptions) {
filters.binary = true;
filters.dontMaskFilenames = true;
(filters as any).preProcessBinaryAsmLines = asmLines => {
const mapFileReader = new MapFileReaderDelphi(unwrap(this.mapFilename));
const reconstructor = new PELabelReconstructor(asmLines, false, mapFileReader, false);
reconstructor.run('output');
return reconstructor.asmLines;
};
return [];
}
}