mirror of
https://github.com/compiler-explorer/compiler-explorer.git
synced 2025-12-27 09:23:52 -05:00
1050 lines
38 KiB
JavaScript
1050 lines
38 KiB
JavaScript
// Copyright (c) 2018, 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 {
|
|
ClientState,
|
|
ClientStateCompiler,
|
|
ClientStateConformanceView,
|
|
ClientStateExecutor,
|
|
} from './clientstate';
|
|
|
|
export class ClientStateNormalizer {
|
|
constructor() {
|
|
this.normalized = new ClientState();
|
|
this.rootContent = null;
|
|
}
|
|
|
|
fromGoldenLayoutContent(content) {
|
|
if (!this.rootContent) this.rootContent = content;
|
|
|
|
for (const component of content) {
|
|
this.fromGoldenLayoutComponent(component);
|
|
}
|
|
}
|
|
|
|
setFilterSettingsFromComponent(compiler, component) {
|
|
compiler.filters.binary = component.componentState.filters.binary;
|
|
compiler.filters.execute = component.componentState.filters.execute;
|
|
compiler.filters.labels = component.componentState.filters.labels;
|
|
compiler.filters.directives = component.componentState.filters.directives;
|
|
compiler.filters.commentOnly = component.componentState.filters.commentOnly;
|
|
compiler.filters.trim = component.componentState.filters.trim;
|
|
compiler.filters.intel = component.componentState.filters.intel;
|
|
compiler.filters.demangle = component.componentState.filters.demangle;
|
|
}
|
|
|
|
findCompilerInGoldenLayout(content, id) {
|
|
let result;
|
|
|
|
for (const component of content) {
|
|
if (component.componentName === 'compiler') {
|
|
if (component.componentState.id === id) {
|
|
return component;
|
|
}
|
|
} else if (component.content && component.content.length > 0) {
|
|
result = this.findCompilerInGoldenLayout(component.content, id);
|
|
if (result) break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
findOrCreateSessionFromEditorOrCompiler(editorId, compilerId) {
|
|
let session;
|
|
if (editorId) {
|
|
session = this.normalized.findOrCreateSession(editorId);
|
|
} else {
|
|
const glCompiler = this.findCompilerInGoldenLayout(this.rootContent, compilerId);
|
|
if (glCompiler) {
|
|
if (glCompiler.componentState.source) {
|
|
session = this.normalized.findOrCreateSession(glCompiler.componentState.source);
|
|
}
|
|
}
|
|
}
|
|
return session;
|
|
}
|
|
|
|
addSpecialOutputToCompiler(compilerId, name, editorId) {
|
|
const glCompiler = this.findCompilerInGoldenLayout(this.rootContent, compilerId);
|
|
if (glCompiler) {
|
|
let compiler;
|
|
if (glCompiler.componentState.source) {
|
|
const session = this.normalized.findOrCreateSession(glCompiler.componentState.source);
|
|
compiler = session.findOrCreateCompiler(compilerId);
|
|
} else if (glCompiler.componentState.tree) {
|
|
const tree = this.normalized.findOrCreateTree(glCompiler.componentState.tree);
|
|
compiler = tree.findOrCreateCompiler(compilerId);
|
|
}
|
|
|
|
compiler.specialoutputs.push(name);
|
|
} else if (editorId) {
|
|
const session = this.normalized.findOrCreateSession(editorId);
|
|
const compiler = session.findOrCreateCompiler(compilerId);
|
|
compiler.specialoutputs.push(name);
|
|
}
|
|
}
|
|
|
|
addToolToCompiler(compilerId, editorId, toolId, args, stdin) {
|
|
const glCompiler = this.findCompilerInGoldenLayout(this.rootContent, compilerId);
|
|
if (glCompiler) {
|
|
let compiler;
|
|
if (glCompiler.componentState.source) {
|
|
const session = this.normalized.findOrCreateSession(glCompiler.componentState.source);
|
|
compiler = session.findOrCreateCompiler(compilerId);
|
|
} else if (glCompiler.componentState.tree) {
|
|
const tree = this.normalized.findOrCreateTree(glCompiler.componentState.tree);
|
|
compiler = tree.findOrCreateCompiler(compilerId);
|
|
}
|
|
|
|
compiler.tools.push({
|
|
id: toolId,
|
|
args: args,
|
|
stdin: stdin,
|
|
});
|
|
}
|
|
}
|
|
|
|
fromGoldenLayoutComponent(component) {
|
|
if (component.componentName === 'tree') {
|
|
const tree = this.normalized.findOrCreateTree(component.componentState.id);
|
|
tree.fromJsonData(component.componentState);
|
|
} else if (component.componentName === 'codeEditor') {
|
|
const session = this.normalized.findOrCreateSession(component.componentState.id);
|
|
session.language = component.componentState.lang;
|
|
session.source = component.componentState.source;
|
|
if (component.componentState.filename)
|
|
session.filename = component.componentState.filename;
|
|
} else if (component.componentName === 'compiler') {
|
|
let compiler;
|
|
if (component.componentState.id) {
|
|
if (component.componentState.source) {
|
|
const session = this.normalized.findOrCreateSession(component.componentState.source);
|
|
compiler = session.findOrCreateCompiler(component.componentState.id);
|
|
} else if (component.componentState.tree) {
|
|
const tree = this.normalized.findOrCreateTree(component.componentState.tree);
|
|
compiler = tree.findOrCreateCompiler(component.componentState.id);
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
compiler = new ClientStateCompiler();
|
|
|
|
if (component.componentState.source) {
|
|
const session = this.normalized.findOrCreateSession(component.componentState.source);
|
|
session.compilers.push(compiler);
|
|
|
|
this.normalized.numberCompilersIfNeeded(session, this.normalized.getNextCompilerId());
|
|
} else if (component.componentState.tree) {
|
|
const tree = this.normalized.findOrCreateTree(component.componentState.tree);
|
|
tree.compilers.push(compiler);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
compiler.id = component.componentState.compiler;
|
|
compiler.options = component.componentState.options;
|
|
compiler.libs = component.componentState.libs;
|
|
this.setFilterSettingsFromComponent(compiler, component);
|
|
} else if (component.componentName === 'executor') {
|
|
const executor = new ClientStateExecutor();
|
|
executor.compiler.id = component.componentState.compiler;
|
|
executor.compiler.options = component.componentState.options;
|
|
executor.compiler.libs = component.componentState.libs;
|
|
executor.compilerVisible = component.componentState.compilationPanelShown;
|
|
executor.compilerOutputVisible = component.componentState.compilerOutShown;
|
|
executor.arguments = component.componentState.execArgs;
|
|
executor.argumentsVisible = component.componentState.argsPanelShown;
|
|
executor.stdin = component.componentState.execStdin;
|
|
executor.stdinVisible = component.componentState.stdinPanelShown;
|
|
if (component.componentState.wrap)
|
|
executor.wrap = true;
|
|
|
|
if (component.componentState.source) {
|
|
const session = this.normalized.findOrCreateSession(component.componentState.source);
|
|
|
|
session.executors.push(executor);
|
|
} else if (component.componentState.tree) {
|
|
const tree = this.normalized.findOrCreateTree(component.componentState.tree);
|
|
|
|
tree.executors.push(executor);
|
|
}
|
|
} else if (component.componentName === 'ast') {
|
|
this.addSpecialOutputToCompiler(component.componentState.id, 'ast',
|
|
component.componentState.editorid);
|
|
} else if (component.componentName === 'opt') {
|
|
this.addSpecialOutputToCompiler(component.componentState.id, 'opt',
|
|
component.componentState.editorid);
|
|
} else if (component.componentName === 'cfg') {
|
|
this.addSpecialOutputToCompiler(component.componentState.id, 'cfg',
|
|
component.componentState.editorid);
|
|
} else if (component.componentName === 'gccdump') {
|
|
this.addSpecialOutputToCompiler(component.componentState._compilerid, 'gccdump',
|
|
component.componentState._editorid);
|
|
} else if (component.componentName === 'output') {
|
|
this.addSpecialOutputToCompiler(component.componentState.compiler, 'compilerOutput',
|
|
component.componentState.editor);
|
|
} else if (component.componentName === 'conformance') {
|
|
const session = this.normalized.findOrCreateSession(component.componentState.editorid);
|
|
session.conformanceview = new ClientStateConformanceView(component.componentState);
|
|
} else if (component.componentName === 'tool') {
|
|
this.addToolToCompiler(component.componentState.compiler, component.componentState.editor,
|
|
component.componentState.toolId, component.componentState.args,
|
|
component.componentState.stdin);
|
|
} else if (component.content) {
|
|
this.fromGoldenLayoutContent(component.content);
|
|
}
|
|
|
|
this.fixFilesInTrees();
|
|
}
|
|
|
|
fixFilesInTrees() {
|
|
for (const tree of this.normalized.trees) {
|
|
tree.files = tree.files.filter((file) => file.isIncluded);
|
|
|
|
for (const file of tree.files) {
|
|
if (file.editorId) {
|
|
const session = this.normalized.findSessionById(file.editorId);
|
|
if (session) {
|
|
file.content = session.source;
|
|
file.filename = session.filename;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fromGoldenLayout(globj) {
|
|
this.rootContent = globj.content;
|
|
|
|
if (globj.content) {
|
|
this.fromGoldenLayoutContent(globj.content);
|
|
}
|
|
}
|
|
}
|
|
|
|
class GoldenLayoutComponents {
|
|
createSourceComponent(session, customSessionId) {
|
|
const editor = {
|
|
type: 'component',
|
|
componentName: 'codeEditor',
|
|
componentState: {
|
|
id: customSessionId ? customSessionId : session.id,
|
|
source: session.source,
|
|
lang: session.language,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
|
|
if (session.filename) {
|
|
editor.title = session.filename;
|
|
editor.componentState.filename = session.filename;
|
|
}
|
|
|
|
return editor;
|
|
}
|
|
|
|
createTreeComponent(tree, customTreeId) {
|
|
const treeComponent = {
|
|
type: 'component',
|
|
componentName: 'tree',
|
|
componentState: {
|
|
id: tree.id,
|
|
cmakeArgs: tree.cmakeArgs,
|
|
customOutputFilename: tree.customOutputFilename,
|
|
isCMakeProject: tree.isCMakeProject,
|
|
compilerLanguageId: tree.compilerLanguageId,
|
|
files: tree.files,
|
|
newFileId: tree.newFileId,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
|
|
if (customTreeId) {
|
|
treeComponent.componentState.id = customTreeId;
|
|
}
|
|
|
|
return treeComponent;
|
|
}
|
|
|
|
createAstComponent(session, compilerIndex, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'ast',
|
|
componentState: {
|
|
id: compilerIndex,
|
|
editorid: customSessionId ? customSessionId : (session ? session.id : undefined),
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createOptComponent(session, compilerIndex, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'opt',
|
|
componentState: {
|
|
id: compilerIndex,
|
|
editorid: customSessionId ? customSessionId : (session ? session.id : undefined),
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createCfgComponent(session, compilerIndex, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'opt',
|
|
componentState: {
|
|
id: compilerIndex,
|
|
editorid: customSessionId ? customSessionId : (session ? session.id : undefined),
|
|
options: {
|
|
navigation: false,
|
|
physics: false,
|
|
},
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createGccDumpComponent(session, compilerIndex, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'gccdump',
|
|
componentState: {
|
|
_compilerid: compilerIndex,
|
|
_editorid: customSessionId ? customSessionId : (session ? session.id : undefined),
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createCompilerOutComponent(session, compilerIndex, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'output',
|
|
componentState: {
|
|
compiler: compilerIndex,
|
|
editor: customSessionId ? customSessionId : (session ? session.id : undefined),
|
|
wrap: false,
|
|
fontScale: 14,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createToolComponent(session, compilerIndex, toolId, args, stdin, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'tool',
|
|
componentState: {
|
|
editor: customSessionId ? customSessionId : (session ? session.id : undefined),
|
|
compiler: compilerIndex,
|
|
toolId: toolId,
|
|
args: args,
|
|
stdin: stdin,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createConformanceViewComponent(session, conformanceview, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'conformance',
|
|
componentState: {
|
|
editorid: customSessionId ? customSessionId : session.id,
|
|
langId: session.language,
|
|
compilers: [],
|
|
libs: conformanceview.libs,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
copyCompilerFilters(filters) {
|
|
return {...filters};
|
|
}
|
|
|
|
createCompilerComponent(session, compiler, customSessionId, idxCompiler) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'compiler',
|
|
componentState: {
|
|
id: idxCompiler,
|
|
compiler: compiler.id,
|
|
source: customSessionId ? customSessionId : session.id,
|
|
options: compiler.options,
|
|
filters: this.copyCompilerFilters(compiler.filters),
|
|
libs: compiler.libs,
|
|
lang: session.language,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createCompilerComponentForTree(tree, compiler, customTreeId, idxCompiler) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'compiler',
|
|
componentState: {
|
|
id: idxCompiler,
|
|
compiler: compiler.id,
|
|
source: undefined,
|
|
tree: customTreeId ? customTreeId : tree.id,
|
|
options: compiler.options,
|
|
filters: this.copyCompilerFilters(compiler.filters),
|
|
libs: compiler.libs,
|
|
lang: tree.compilerLanguageId,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createExecutorComponent(session, executor, customSessionId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'executor',
|
|
componentState: {
|
|
compiler: executor.compiler.id,
|
|
source: customSessionId ? customSessionId : session.id,
|
|
options: executor.compiler.options,
|
|
execArgs: executor.arguments,
|
|
execStdin: executor.stdin,
|
|
libs: executor.compiler.libs,
|
|
lang: session.language,
|
|
compilationPanelShown: executor.compilerVisible,
|
|
compilerOutShown: executor.compilerOutputVisible,
|
|
argsPanelShown: executor.argumentsVisible,
|
|
stdinPanelShown: executor.stdinVisible,
|
|
wrap: executor.wrap,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createExecutorComponentForTree(tree, executor, customTreeId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'executor',
|
|
componentState: {
|
|
compiler: executor.compiler.id,
|
|
source: undefined,
|
|
tree: customTreeId ? customTreeId : tree.id,
|
|
options: executor.compiler.options,
|
|
execArgs: executor.arguments,
|
|
execStdin: executor.stdin,
|
|
libs: executor.compiler.libs,
|
|
lang: tree.compilerLanguageId,
|
|
compilationPanelShown: executor.compilerVisible,
|
|
compilerOutShown: executor.compilerOutputVisible,
|
|
argsPanelShown: executor.argumentsVisible,
|
|
stdinPanelShown: executor.stdinVisible,
|
|
wrap: executor.wrap,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
|
|
createDiffComponent(left, right) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'diff',
|
|
componentState: {
|
|
lhs: left,
|
|
rhs: right,
|
|
lhsdifftype: 0,
|
|
rhsdifftype: 0,
|
|
fontScale: 14,
|
|
},
|
|
};
|
|
}
|
|
|
|
createSpecialOutputComponent(viewtype, session, idxCompiler, customSessionId) {
|
|
let component = null;
|
|
if (viewtype === 'ast') {
|
|
component = this.createAstComponent(session, idxCompiler + 1, customSessionId);
|
|
} else if (viewtype === 'opt') {
|
|
component = this.createOptComponent(session, idxCompiler + 1, customSessionId);
|
|
} else if (viewtype === 'cfg') {
|
|
component = this.createCfgComponent(session, idxCompiler + 1, customSessionId);
|
|
} else if (viewtype === 'gccdump') {
|
|
component = this.createGccDumpComponent(session, idxCompiler + 1, customSessionId);
|
|
} else if (viewtype === 'compilerOutput') {
|
|
component = this.createCompilerOutComponent(session, idxCompiler + 1, customSessionId);
|
|
}
|
|
|
|
return component;
|
|
}
|
|
|
|
createSpecialOutputComponentForTreeCompiler(viewtype, idxCompiler) {
|
|
let component = null;
|
|
if (viewtype === 'ast') {
|
|
component = this.createAstComponent(null, idxCompiler + 1, false);
|
|
} else if (viewtype === 'opt') {
|
|
component = this.createOptComponent(null, idxCompiler + 1, false);
|
|
} else if (viewtype === 'cfg') {
|
|
component = this.createCfgComponent(null, idxCompiler + 1, false);
|
|
} else if (viewtype === 'gccdump') {
|
|
component = this.createGccDumpComponent(null, idxCompiler + 1, false);
|
|
} else if (viewtype === 'compilerOutput') {
|
|
component = this.createCompilerOutComponent(null, idxCompiler + 1, false);
|
|
}
|
|
|
|
return component;
|
|
}
|
|
|
|
createToolComponentForTreeCompiler(tree, compilerIndex, toolId, args, stdin, customTreeId) {
|
|
return {
|
|
type: 'component',
|
|
componentName: 'tool',
|
|
componentState: {
|
|
tree: customTreeId ? customTreeId : (tree ? tree.id : undefined),
|
|
compiler: compilerIndex,
|
|
toolId: toolId,
|
|
args: args,
|
|
stdin: stdin,
|
|
},
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
};
|
|
}
|
|
}
|
|
|
|
export class ClientStateGoldenifier extends GoldenLayoutComponents {
|
|
constructor() {
|
|
super();
|
|
this.golden = {};
|
|
}
|
|
|
|
newEmptyStack(width) {
|
|
return {
|
|
type: 'stack',
|
|
width: width,
|
|
content: [],
|
|
};
|
|
}
|
|
|
|
newStackWithOneComponent(width, component) {
|
|
return {
|
|
type: 'stack',
|
|
width: width,
|
|
content: [component],
|
|
};
|
|
}
|
|
|
|
newTreeFromTree(tree, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createTreeComponent(tree),
|
|
);
|
|
}
|
|
|
|
newSourceStackFromSession(session, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createSourceComponent(session),
|
|
);
|
|
}
|
|
|
|
newAstStackFromCompiler(session, compilerIndex, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createAstComponent(session, compilerIndex),
|
|
);
|
|
}
|
|
|
|
newOptStackFromCompiler(session, compilerIndex, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createOptComponent(session, compilerIndex),
|
|
);
|
|
}
|
|
|
|
newCfgStackFromCompiler(session, compilerIndex, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createCfgComponent(session, compilerIndex),
|
|
);
|
|
}
|
|
|
|
newGccDumpStackFromCompiler(session, compilerIndex, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createGccDumpComponent(session, compilerIndex),
|
|
);
|
|
}
|
|
|
|
newCompilerOutStackFromCompiler(session, compilerIndex, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createCompilerOutComponent(session, compilerIndex),
|
|
);
|
|
}
|
|
|
|
newToolStackFromCompiler(session, compilerIndex, toolId, args, stdin, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createToolComponent(session, compilerIndex, toolId, args, stdin),
|
|
);
|
|
}
|
|
|
|
newConformanceViewStack(session, width, conformanceview) {
|
|
const stack = this.newStackWithOneComponent(width,
|
|
this.createConformanceViewComponent(session, conformanceview),
|
|
);
|
|
|
|
for (const compiler of conformanceview.compilers) {
|
|
const compjson = {
|
|
compilerId: compiler.id,
|
|
options: compiler.options,
|
|
};
|
|
|
|
stack.content[0].componentState.compilers.push(compjson);
|
|
}
|
|
|
|
return stack;
|
|
}
|
|
|
|
newCompilerStackFromSession(session, compiler, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createCompilerComponent(session, compiler, false, compiler._internalId),
|
|
);
|
|
}
|
|
|
|
newExecutorStackFromSession(session, executor, width) {
|
|
return this.newStackWithOneComponent(width,
|
|
this.createExecutorComponent(session, executor),
|
|
);
|
|
}
|
|
|
|
createSourceContentArray(state, left, right) {
|
|
if (left.session === right.session) {
|
|
return [this.createPresentationModeComponents(state.sessions[left.session], 1, 100)];
|
|
} else {
|
|
return [
|
|
this.createPresentationModeComponents(state.sessions[left.session], 1),
|
|
this.createPresentationModeComponents(state.sessions[right.session], 2),
|
|
];
|
|
}
|
|
}
|
|
|
|
getPresentationModeEmptyLayout() {
|
|
return {
|
|
settings: {
|
|
hasHeaders: true,
|
|
constrainDragToContainer: false,
|
|
reorderEnabled: true,
|
|
selectionEnabled: false,
|
|
popoutWholeStack: false,
|
|
blockedPopoutsThrowError: true,
|
|
closePopoutsOnUnload: true,
|
|
showPopoutIcon: false,
|
|
showMaximiseIcon: true,
|
|
showCloseIcon: false,
|
|
responsiveMode: 'onload',
|
|
tabOverlapAllowance: 0,
|
|
reorderOnTabMenuClick: true,
|
|
tabControlOffset: 10,
|
|
},
|
|
dimensions: {
|
|
borderWidth: 5,
|
|
borderGrabWidth: 15,
|
|
minItemHeight: 10,
|
|
minItemWidth: 10,
|
|
headerHeight: 20,
|
|
dragProxyWidth: 300,
|
|
dragProxyHeight: 200,
|
|
},
|
|
labels: {
|
|
close: 'close',
|
|
maximise: 'maximise',
|
|
minimise: 'minimise',
|
|
popout: 'open in new window',
|
|
popin: 'pop in',
|
|
tabDropdown: 'additional tabs',
|
|
},
|
|
content: [
|
|
{
|
|
type: 'column',
|
|
content: [],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
getPresentationModeLayoutForSource(state, left) {
|
|
const gl = this.getPresentationModeEmptyLayout();
|
|
gl.content[0].content = [
|
|
{
|
|
type: 'column',
|
|
width: 100,
|
|
content: this.createSourceContentArray(state, left, left),
|
|
}];
|
|
|
|
return gl;
|
|
}
|
|
|
|
closeAllEditors(tree) {
|
|
for (const file of tree.files) {
|
|
file.editorId = -1;
|
|
file.isOpen = false;
|
|
}
|
|
}
|
|
|
|
getPresentationModeLayoutForTree(state, left) {
|
|
const gl = this.getPresentationModeEmptyLayout();
|
|
const tree = state.trees[left.tree];
|
|
const customTreeId = 1;
|
|
|
|
this.closeAllEditors(tree);
|
|
|
|
gl.content[0].content = [
|
|
{
|
|
type: 'column',
|
|
width: 100,
|
|
content: [
|
|
{
|
|
type: 'row',
|
|
height: 50,
|
|
content: [this.createTreeComponent(tree, customTreeId)],
|
|
},
|
|
{
|
|
type: 'row',
|
|
height: 50,
|
|
content: [
|
|
{
|
|
type: 'stack',
|
|
width: 100,
|
|
content: [],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
}];
|
|
|
|
let stack = gl.content[0].content[0].content[1].content[0];
|
|
|
|
for (let idxCompiler = 0; idxCompiler < tree.compilers.length; idxCompiler++) {
|
|
const compiler = tree.compilers[idxCompiler];
|
|
stack.content.push(
|
|
this.createCompilerComponentForTree(tree, compiler, customTreeId, idxCompiler + 1),
|
|
);
|
|
|
|
for (const viewtype of compiler.specialoutputs) {
|
|
stack.content.push(
|
|
this.createSpecialOutputComponentForTreeCompiler(viewtype, idxCompiler),
|
|
);
|
|
}
|
|
|
|
for (const tool of compiler.tools) {
|
|
stack.content.push(
|
|
this.createToolComponentForTreeCompiler(tree, idxCompiler + 1, tool.id,
|
|
tool.args, tool.stdin),
|
|
);
|
|
}
|
|
}
|
|
|
|
for (let idxExecutor = 0; idxExecutor < tree.executors.length; idxExecutor++) {
|
|
stack.content.push(
|
|
this.createExecutorComponentForTree(tree, tree.executors[idxExecutor], customTreeId),
|
|
);
|
|
}
|
|
|
|
return gl;
|
|
}
|
|
|
|
getPresentationModeLayoutForComparisonSlide(state, left, right) {
|
|
const gl = this.getPresentationModeEmptyLayout();
|
|
gl.content[0].content = [
|
|
{
|
|
type: 'row',
|
|
height: 50,
|
|
content: this.createSourceContentArray(state, left, right),
|
|
},
|
|
{
|
|
type: 'row',
|
|
height: 50,
|
|
content: [
|
|
{
|
|
type: 'stack',
|
|
width: 100,
|
|
content: [
|
|
this.createDiffComponent(left.compiler + 1, right.compiler + 1),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
];
|
|
|
|
return gl;
|
|
}
|
|
|
|
createPresentationModeComponents(session, customSessionId, customWidth) {
|
|
const stack = {
|
|
type: 'stack',
|
|
width: customWidth ? customWidth : 50,
|
|
activeItemIndex: 0,
|
|
content: [
|
|
this.createSourceComponent(session, customSessionId),
|
|
],
|
|
};
|
|
|
|
for (let idxCompiler = 0; idxCompiler < session.compilers.length; idxCompiler++) {
|
|
const compiler = session.compilers[idxCompiler];
|
|
stack.content.push(
|
|
this.createCompilerComponent(session, compiler, customSessionId),
|
|
);
|
|
|
|
for (const viewtype of compiler.specialoutputs) {
|
|
stack.content.push(
|
|
this.createSpecialOutputComponent(viewtype, session, idxCompiler, customSessionId),
|
|
);
|
|
}
|
|
|
|
for (const tool of compiler.tools) {
|
|
stack.content.push(
|
|
this.createToolComponent(false, idxCompiler + 1, tool.id, tool.args, tool.stdin, customSessionId),
|
|
);
|
|
}
|
|
}
|
|
|
|
for (let idxExecutor = 0; idxExecutor < session.executors.length; idxExecutor++) {
|
|
stack.content.push(
|
|
this.createExecutorComponent(session, session.executors[idxExecutor], customSessionId),
|
|
);
|
|
}
|
|
|
|
return stack;
|
|
}
|
|
|
|
generatePresentationModeMobileViewerSlides(state) {
|
|
const slides = [];
|
|
|
|
if (state.trees.length > 0) {
|
|
for (var idxTree = 0; idxTree < state.trees.length; idxTree++) {
|
|
const gl = this.getPresentationModeLayoutForTree(state, {
|
|
tree: idxTree,
|
|
});
|
|
slides.push(gl);
|
|
}
|
|
|
|
return slides;
|
|
}
|
|
|
|
for (var idxSession = 0; idxSession < state.sessions.length; idxSession++) {
|
|
const gl = this.getPresentationModeLayoutForSource(state, {
|
|
session: idxSession,
|
|
compiler: 0,
|
|
});
|
|
slides.push(gl);
|
|
}
|
|
|
|
return slides;
|
|
}
|
|
|
|
treeLayoutFromClientstate(state) {
|
|
const firstTree = state.trees[0];
|
|
const leftSide = this.newTreeFromTree(firstTree, 25);
|
|
const middle = this.newEmptyStack(40);
|
|
for (const session of state.sessions) {
|
|
middle.content.push(this.createSourceComponent(session));
|
|
}
|
|
|
|
const rightSide = this.newEmptyStack(40);
|
|
let idxCompiler = 0;
|
|
for (const compiler of firstTree.compilers) {
|
|
rightSide.content.push(this.createCompilerComponentForTree(firstTree, compiler));
|
|
|
|
for (const specialOutput of compiler.specialoutputs) {
|
|
rightSide.content.push(this.createSpecialOutputComponentForTreeCompiler(specialOutput, idxCompiler));
|
|
}
|
|
|
|
idxCompiler++;
|
|
}
|
|
|
|
this.golden.content[0].content.push(leftSide, middle, rightSide);
|
|
}
|
|
|
|
fromClientState(state) {
|
|
this.golden = {
|
|
settings: {
|
|
hasHeaders: true,
|
|
constrainDragToContainer: false,
|
|
reorderEnabled: true,
|
|
selectionEnabled: false,
|
|
popoutWholeStack: false,
|
|
blockedPopoutsThrowError: true,
|
|
closePopoutsOnUnload: true,
|
|
showPopoutIcon: false,
|
|
showMaximiseIcon: true,
|
|
showCloseIcon: true,
|
|
responsiveMode: 'onload',
|
|
tabOverlapAllowance: 0,
|
|
reorderOnTabMenuClick: true,
|
|
tabControlOffset: 10,
|
|
},
|
|
dimensions: {
|
|
borderWidth: 5,
|
|
borderGrabWidth: 15,
|
|
minItemHeight: 10,
|
|
minItemWidth: 10,
|
|
headerHeight: 20,
|
|
dragProxyWidth: 300,
|
|
dragProxyHeight: 200,
|
|
},
|
|
labels: {
|
|
close: 'close',
|
|
maximise: 'maximise',
|
|
minimise: 'minimise',
|
|
popout: 'open in new window',
|
|
popin: 'pop in',
|
|
tabDropdown: 'additional tabs',
|
|
},
|
|
content: [
|
|
{
|
|
type: 'row',
|
|
content: [],
|
|
},
|
|
],
|
|
};
|
|
|
|
if (state.trees.length > 0) {
|
|
this.treeLayoutFromClientstate(state);
|
|
return;
|
|
}
|
|
|
|
if (state.sessions.length > 1) {
|
|
const sessionWidth = 100 / state.sessions.length;
|
|
|
|
for (let idxSession = 0; idxSession < state.sessions.length; idxSession++) {
|
|
const session = state.sessions[idxSession];
|
|
|
|
this.golden.content[0].content[idxSession] = {
|
|
type: 'column',
|
|
isClosable: true,
|
|
reorderEnabled: true,
|
|
width: sessionWidth,
|
|
content: [
|
|
{
|
|
type: 'row',
|
|
content: [],
|
|
},
|
|
{
|
|
type: 'row',
|
|
content: [],
|
|
},
|
|
],
|
|
};
|
|
|
|
let stack = this.newSourceStackFromSession(session, 100);
|
|
this.golden.content[0].content[idxSession].content[0].content.push(stack);
|
|
|
|
const compilerWidth = 100 /
|
|
(1 + session.compilers.length + session.executors.length +
|
|
session.countNumberOfSpecialOutputsAndTools());
|
|
|
|
if (session.conformanceview) {
|
|
const stack = this.newConformanceViewStack(session, compilerWidth, session.conformanceview);
|
|
this.golden.content[0].content[idxSession].content[1].content.push(stack);
|
|
}
|
|
|
|
for (let idxCompiler = 0; idxCompiler < session.compilers.length; idxCompiler++) {
|
|
const compiler = session.compilers[idxCompiler];
|
|
let stack = this.newCompilerStackFromSession(session, compiler, compilerWidth);
|
|
this.golden.content[0].content[idxSession].content[1].content.push(stack);
|
|
|
|
for (const viewtype of compiler.specialoutputs) {
|
|
let stack = this.newStackWithOneComponent(compilerWidth,
|
|
this.createSpecialOutputComponent(viewtype, session, idxCompiler));
|
|
|
|
if (stack) {
|
|
this.golden.content[0].content[idxSession].content[1].content.push(stack);
|
|
}
|
|
}
|
|
|
|
for (const tool of compiler.tools) {
|
|
let stack = this.newToolStackFromCompiler(session, idxCompiler + 1,
|
|
tool.id, tool.args, tool.stdin, compilerWidth);
|
|
this.golden.content[0].content[idxSession].content[1].content.push(stack);
|
|
}
|
|
}
|
|
|
|
for (let idxExecutor = 0; idxExecutor < session.executors.length; idxExecutor++) {
|
|
const executor = session.executors[idxExecutor];
|
|
let stack = this.newExecutorStackFromSession(session, executor, compilerWidth);
|
|
this.golden.content[0].content[idxSession].content[1].content.push(stack);
|
|
}
|
|
}
|
|
} else if (state.sessions.length === 1) {
|
|
const session = state.sessions[0];
|
|
this.golden.content[0] = {
|
|
type: 'row',
|
|
content: [],
|
|
};
|
|
|
|
const width = 100 / (1 + session.compilers.length + session.executors.length +
|
|
session.countNumberOfSpecialOutputsAndTools());
|
|
this.golden.content[0].content.push(this.newSourceStackFromSession(session, width));
|
|
|
|
if (session.conformanceview) {
|
|
const stack = this.newConformanceViewStack(session, width, session.conformanceview);
|
|
this.golden.content[0].content.push(stack);
|
|
}
|
|
|
|
for (let idxCompiler = 0; idxCompiler < session.compilers.length; idxCompiler++) {
|
|
const compiler = session.compilers[idxCompiler];
|
|
let stack = this.newCompilerStackFromSession(session, compiler, width);
|
|
this.golden.content[0].content.push(stack);
|
|
|
|
for (const viewtype of compiler.specialoutputs) {
|
|
let stack = this.newStackWithOneComponent(width,
|
|
this.createSpecialOutputComponent(viewtype, session, idxCompiler));
|
|
|
|
if (stack) {
|
|
this.golden.content[0].content.push(stack);
|
|
}
|
|
}
|
|
|
|
for (const tool of compiler.tools) {
|
|
let stack = this.newToolStackFromCompiler(session, compiler, idxCompiler + 1,
|
|
tool.id, tool.args, tool.stdin, width);
|
|
this.golden.content[0].content.push(stack);
|
|
}
|
|
}
|
|
|
|
for (const executor of session.executors) {
|
|
let stack = this.newExecutorStackFromSession(session, executor, width);
|
|
this.golden.content[0].content.push(stack);
|
|
}
|
|
}
|
|
}
|
|
}
|