// instantiate a function that generate javascript code,
function ClientOptionsHandler(fileSources) {
var sources = fileSources.map(function (source) {
return {name: source.name, urlpart: source.urlpart};
});
// sort source file alphabetically
sources = sources.sort(compareOn("name"));
var languages = _.compact(_.map(gccProps("languages", '').split(':'), function (thing) {
if (!thing) return null;
var splat = thing.split("=");
return {language: splat[0], url: splat[1]};
}));
var supportsBinary = !!compilerProps("supportsBinary", true);
var supportsExecute = supportsBinary && !!compilerProps("supportsExecute", true);
var options = {
googleAnalyticsAccount: gccProps('clientGoogleAnalyticsAccount', 'UA-55180-6'),
googleAnalyticsEnabled: gccProps('clientGoogleAnalyticsEnabled', false),
sharingEnabled: gccProps('clientSharingEnabled', true),
githubEnabled: gccProps('clientGitHubRibbonEnabled', true),
gapiKey: gccProps('googleApiKey', ''),
googleShortLinkRewrite: gccProps('googleShortLinkRewrite', '').split('|'),
defaultSource: gccProps('defaultSource', ''),
language: language,
compilers: [],
sourceExtension: compilerProps('compileFilename').split('.', 2)[1],
defaultCompiler: compilerProps('defaultCompiler', ''),
compileOptions: compilerProps('defaultOptions', ''),
supportsBinary: supportsBinary,
supportsExecute: supportsExecute,
languages: languages,
sources: sources,
raven: gccProps('ravenUrl', ''),
release: gitReleaseName,
environment: env,
localStoragePrefix: gccProps('localStoragePrefix'),
cvCompilerCountMax: gccProps('cvCompilerCountMax', 6)
};
this.setCompilers = function (compilers) {
options.compilers = compilers;
};
this.setCompilers([]);
this.handler = function getClientOptions(req, res) {
res.set('Content-Type', 'application/json');
staticHeaders(res);
res.end(JSON.stringify(options));
};
this.get = function () {
return options;
};
}
postProcess(result, outputFilename, filters) {
const postProcess = _.compact(this.compiler.postProcess);
const maxSize = this.env.ceProps("max-asm-size", 8 * 1024 * 1024);
let optPromise, asmPromise, execPromise;
if (result.hasOptOutput) {
optPromise = this.processOptOutput(result.hasOptOutput, result.optPath);
} else {
optPromise = Promise.resolve("");
}
if (filters.binary && this.supportsObjdump()) {
asmPromise = this.objdump(outputFilename, result, maxSize, filters.intel, filters.demangle);
} else {
asmPromise = this.stat(outputFilename).then(stat => {
if (stat.size >= maxSize) {
result.asm = `<No output: generated assembly was too large (${stat.size} > ${maxSize} bytes)>`;
return result;
}
if (postProcess.length) {
return this.execPostProcess(result, postProcess, outputFilename, maxSize);
} else {
return this.readFile(outputFilename).then(contents => {
result.asm = contents.toString();
return Promise.resolve(result);
});
}
},
() => {
result.asm = "<No output file>";
return result;
});
}
if (filters.execute) {
const maxExecOutputSize = this.env.ceProps("max-executable-output-size", 32 * 1024);
execPromise = this.execBinary(outputFilename, result, maxExecOutputSize);
} else {
execPromise = Promise.resolve("");
}
return Promise.all([asmPromise, optPromise, execPromise]);
}
const compileToAsmPromise = tempFileAndDirPromise.then(info => {
const inputFilename = info.inputFilename;
const inputFilenameSafe = this.filename(inputFilename);
const dirPath = info.dirPath;
const outputFilebase = "output";
const outputFilename = this.getOutputFilename(dirPath, outputFilebase);
options = _.compact(this.prepareArguments(options, filters, backendOptions, inputFilename, outputFilename));
const execOptions = this.getDefaultExecOptions();
const asmPromise = this.runCompiler(this.compiler.exe, options, inputFilenameSafe, execOptions);
let astPromise;
if (backendOptions && backendOptions.produceAst) {
if (this.compiler.supportsAstView) {
astPromise = this.generateAST(inputFilename, options);
}
else {
astPromise = Promise.resolve("AST output is only supported in Clang >= 3.3");
}
}
else {
astPromise = Promise.resolve("");
}
let gccDumpPromise;
if (backendOptions && backendOptions.produceGccDump && backendOptions.produceGccDump.opened) {
gccDumpPromise = this.generateGccDump(inputFilename, options, backendOptions.produceGccDump);
}
else {
gccDumpPromise = Promise.resolve("");
}
return Promise.all([asmPromise, astPromise, gccDumpPromise])
.then(([asmResult, astResult, gccDumpResult]) => {
asmResult.dirPath = dirPath;
if (asmResult.code !== 0) {
asmResult.asm = "<Compilation failed>";
return asmResult;
}
asmResult.hasOptOutput = false;
if (this.compiler.supportsOptOutput && this.optOutputRequested(options)) {
const optPath = path.join(dirPath, `${outputFilebase}.opt.yaml`);
if (fs.existsSync(optPath)) {
asmResult.hasOptOutput = true;
asmResult.optPath = optPath;
}
}
if (astResult) {
asmResult.hasAstOutput = true;
asmResult.astOutput = astResult;
}
if (this.compiler.supportsGccDump && gccDumpResult) {
asmResult.hasGccDumpOutput = true;
asmResult.gccDumpOutput = gccDumpResult;
}
return this.checkOutputFileAndDoPostProcess(asmResult, outputFilename, filters);
});
});
// instantiate a function that generate javascript code,
function ClientOptionsHandler(fileSources) {
var sources = fileSources.map(function (source) {
return {name: source.name, urlpart: source.urlpart};
});
// sort source file alphabetically
sources = sources.sort(compareOn("name"));
var languages = _.compact(_.map(gccProps("languages", '').split(':'), function (thing) {
if (!thing) return null;
var splat = thing.split("=");
return {language: splat[0], url: splat[1]};
}));
var supportsBinary = !!compilerProps("supportsBinary", true);
var supportsExecute = supportsBinary && !!compilerProps("supportsExecute", true);
var libs = {};
var baseLibs = compilerProps("libs");
if (baseLibs) {
_.each(baseLibs.split(':'), function (lib) {
libs[lib] = {name: compilerProps('libs.' + lib + '.name')};
libs[lib].versions = {};
var listedVersions = compilerProps("libs." + lib + '.versions');
if (listedVersions) {
_.each(listedVersions.split(':'), function (version) {
libs[lib].versions[version] = {};
libs[lib].versions[version].version = compilerProps("libs." + lib + '.versions.' + version + '.version');
libs[lib].versions[version].path = [];
var listedIncludes = compilerProps("libs." + lib + '.versions.' + version + '.path');
if (listedIncludes) {
_.each(listedIncludes.split(':'), function (path) {
libs[lib].versions[version].path.push(path);
});
} else {
logger.warn("No paths found for " + lib + " version " + version);
}
});
} else {
logger.warn("No versions found for " + lib + " library");
}
});
}
var options = {
googleAnalyticsAccount: gccProps('clientGoogleAnalyticsAccount', 'UA-55180-6'),
googleAnalyticsEnabled: gccProps('clientGoogleAnalyticsEnabled', false),
sharingEnabled: gccProps('clientSharingEnabled', true),
githubEnabled: gccProps('clientGitHubRibbonEnabled', true),
gapiKey: gccProps('googleApiKey', ''),
googleShortLinkRewrite: gccProps('googleShortLinkRewrite', '').split('|'),
defaultSource: gccProps('defaultSource', ''),
language: language,
compilers: [],
libs: libs,
sourceExtension: compilerProps('compileFilename').split('.', 2)[1],
defaultCompiler: compilerProps('defaultCompiler', ''),
compileOptions: compilerProps('defaultOptions', ''),
supportsBinary: supportsBinary,
supportsExecute: supportsExecute,
languages: languages,
sources: sources,
raven: gccProps('ravenUrl', ''),
release: gitReleaseName,
environment: env,
localStoragePrefix: gccProps('localStoragePrefix'),
cvCompilerCountMax: gccProps('cvCompilerCountMax', 6),
defaultFontScale: gccProps('defaultFontScale', 1.0)
};
this.setCompilers = function (compilers) {
options.compilers = compilers;
};
this.setCompilers([]);
this.handler = function getClientOptions(req, res) {
res.set('Content-Type', 'application/json');
staticHeaders(res);
res.end(JSON.stringify(options));
};
this.get = function () {
return options;
};
}