/**
* Do an initial pass over the lines and gather info about the line comment string.
* Returns null if any of the lines doesn't support a line comment string.
*/
public static _gatherPreflightCommentStrings(model: editorCommon.ITokenizedModel, startLineNumber: number, endLineNumber: number): ILinePreflightData[] {
let commentStrForLanguage: string[] = [];
let lines: ILinePreflightData[] = [];
for (let i = 0, lineCount = endLineNumber - startLineNumber + 1; i < lineCount; i++) {
let lineNumber = startLineNumber + i;
let languageId = model.getLanguageIdAtPosition(lineNumber, 1);
// Find the commentStr for this line, if none is found then bail out: we cannot do line comments
let commentStr: string;
if (commentStrForLanguage[languageId]) {
commentStr = commentStrForLanguage[languageId];
} else {
let config = LanguageConfigurationRegistry.getComments(languageId);
commentStr = (config ? config.lineCommentToken : null);
if (!commentStr) {
// Mode does not support line comments
return null;
}
commentStrForLanguage[languageId] = commentStr;
}
lines.push({
ignore: false,
commentStr: commentStr,
commentStrOffset: 0,
commentStrLength: commentStr.length
});
}
return lines;
}
public getEditOperations(model: ITextModel, builder: editorCommon.IEditOperationBuilder): void {
const startLineNumber = this._selection.startLineNumber;
const startColumn = this._selection.startColumn;
model.tokenizeIfCheap(startLineNumber);
const languageId = model.getLanguageIdAtPosition(startLineNumber, startColumn);
const config = LanguageConfigurationRegistry.getComments(languageId);
if (!config || !config.blockCommentStartToken || !config.blockCommentEndToken) {
// Mode does not support block comments
return;
}
this._createOperationsForBlockComment(this._selection, config.blockCommentStartToken, config.blockCommentEndToken, model, builder);
}
/**
* Given an unsuccessful analysis, delegate to the block comment command
*/
private _executeBlockComment(model: editorCommon.ITokenizedModel, builder: editorCommon.IEditOperationBuilder, s: Selection): void {
model.forceTokenization(s.startLineNumber);
let languageId = model.getLanguageIdAtPosition(s.startLineNumber, s.startColumn);
let config = LanguageConfigurationRegistry.getComments(languageId);
if (!config || !config.blockCommentStartToken || !config.blockCommentEndToken) {
// Mode does not support block comments
return;
}
var startToken = config.blockCommentStartToken;
var endToken = config.blockCommentEndToken;
var ops = this._attemptRemoveBlockComment(model, s, startToken, endToken);
if (!ops) {
if (s.isEmpty()) {
var lineContent = model.getLineContent(s.startLineNumber);
var firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(lineContent);
if (firstNonWhitespaceIndex === -1) {
// Line is empty or contains only whitespace
firstNonWhitespaceIndex = lineContent.length;
}
ops = BlockCommentCommand._createAddBlockCommentOperations({
startLineNumber: s.startLineNumber,
startColumn: firstNonWhitespaceIndex + 1,
endLineNumber: s.startLineNumber,
endColumn: lineContent.length + 1
}, startToken, endToken);
} else {
ops = BlockCommentCommand._createAddBlockCommentOperations({
startLineNumber: s.startLineNumber,
startColumn: model.getLineFirstNonWhitespaceColumn(s.startLineNumber),
endLineNumber: s.endLineNumber,
endColumn: model.getLineMaxColumn(s.endLineNumber)
}, startToken, endToken);
}
if (ops.length === 1) {
this._deltaColumn = startToken.length;
}
}
this._selectionId = builder.trackSelection(s);
for (var i = 0; i < ops.length; i++) {
builder.addEditOperation(ops[i].range, ops[i].text);
}
}
public getEditOperations(model: editorCommon.ITokenizedModel, builder: editorCommon.IEditOperationBuilder): void {
var startLineNumber = this._selection.startLineNumber;
var startColumn = this._selection.startColumn;
var endLineNumber = this._selection.endLineNumber;
var endColumn = this._selection.endColumn;
model.forceTokenization(startLineNumber);
let languageId = model.getLanguageIdAtPosition(startLineNumber, startColumn);
let config = LanguageConfigurationRegistry.getComments(languageId);
if (!config || !config.blockCommentStartToken || !config.blockCommentEndToken) {
// Mode does not support block comments
return;
}
this._createOperationsForBlockComment(
new Range(startLineNumber, startColumn, endLineNumber, endColumn), config, model, builder
);
}
/**
* Given an unsuccessful analysis, delegate to the block comment command
*/
private _executeBlockComment(model: ITextModel, builder: editorCommon.IEditOperationBuilder, s: Selection): void {
model.tokenizeIfCheap(s.startLineNumber);
let languageId = model.getLanguageIdAtPosition(s.startLineNumber, 1);
let config = LanguageConfigurationRegistry.getComments(languageId);
if (!config || !config.blockCommentStartToken || !config.blockCommentEndToken) {
// Mode does not support block comments
return;
}
const startToken = config.blockCommentStartToken;
const endToken = config.blockCommentEndToken;
let ops = this._attemptRemoveBlockComment(model, s, startToken, endToken);
if (!ops) {
if (s.isEmpty()) {
const lineContent = model.getLineContent(s.startLineNumber);
let firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(lineContent);
if (firstNonWhitespaceIndex === -1) {
// Line is empty or contains only whitespace
firstNonWhitespaceIndex = lineContent.length;
}
ops = BlockCommentCommand._createAddBlockCommentOperations(
new Range(s.startLineNumber, firstNonWhitespaceIndex + 1, s.startLineNumber, lineContent.length + 1), startToken, endToken
);
} else {
ops = BlockCommentCommand._createAddBlockCommentOperations(
new Range(s.startLineNumber, model.getLineFirstNonWhitespaceColumn(s.startLineNumber), s.endLineNumber, model.getLineMaxColumn(s.endLineNumber)), startToken, endToken
);
}
if (ops.length === 1) {
// Leave cursor after token and Space
this._deltaColumn = startToken.length + 1;
}
}
this._selectionId = builder.trackSelection(s);
for (let i = 0; i < ops.length; i++) {
builder.addEditOperation(ops[i].range, ops[i].text);
}
}
/**
* Do an initial pass over the lines and gather info about the line comment string.
* Returns null if any of the lines doesn't support a line comment string.
*/
public static _gatherPreflightCommentStrings(model:editorCommon.ITokenizedModel, startLineNumber: number, endLineNumber: number): ILinePreflightData[] {
var lines: ILinePreflightData[] = [],
config:ICommentsConfiguration,
commentStr:string,
seenModes: {[modeId:string]:string;} = Object.create(null),
i:number,
lineCount:number,
lineNumber:number,
mode: IMode,
modeId: string;
for (i = 0, lineCount = endLineNumber - startLineNumber + 1; i < lineCount; i++) {
lineNumber = startLineNumber + i;
mode = model.getModeAtPosition(lineNumber, 1);
modeId = mode.getId();
// Find the commentStr for this line, if none is found then bail out: we cannot do line comments
if (seenModes[modeId]) {
commentStr = seenModes[modeId];
} else {
config = LanguageConfigurationRegistry.getComments(mode);
commentStr = (config ? config.lineCommentToken : null);
if (!commentStr) {
// Mode does not support line comments
return null;
}
seenModes[modeId] = commentStr;
}
lines.push({
ignore: false,
commentStr: commentStr,
commentStrOffset: 0,
commentStrLength: commentStr.length
});
}
return lines;
}
/**
* Do an initial pass over the lines and gather info about the line comment string.
* Returns null if any of the lines doesn't support a line comment string.
*/
public static _gatherPreflightCommentStrings(model: editorCommon.ITokenizedModel, startLineNumber: number, endLineNumber: number): ILinePreflightData[] {
model.forceTokenization(startLineNumber);
const languageId = model.getLanguageIdAtPosition(startLineNumber, 1);
const config = LanguageConfigurationRegistry.getComments(languageId);
const commentStr = (config ? config.lineCommentToken : null);
if (!commentStr) {
// Mode does not support line comments
return null;
}
let lines: ILinePreflightData[] = [];
for (let i = 0, lineCount = endLineNumber - startLineNumber + 1; i < lineCount; i++) {
lines[i] = {
ignore: false,
commentStr: commentStr,
commentStrOffset: 0,
commentStrLength: commentStr.length
};
}
return lines;
}