void QtScriptHighlighter::onBlockEnd(int state, int firstNonSpace)
{
typedef TextEditor::TextBlockUserData TextEditorBlockData;
setCurrentBlockState((m_braceDepth << 8) | state);
// Set block data parentheses. Force creation of block data unless empty
TextEditorBlockData *blockData = 0;
if (QTextBlockUserData *userData = currentBlockUserData())
blockData = static_cast<TextEditorBlockData *>(userData);
if (!blockData && !m_currentBlockParentheses.empty()) {
blockData = new TextEditorBlockData;
setCurrentBlockUserData(blockData);
}
if (blockData) {
blockData->setParentheses(m_currentBlockParentheses);
blockData->setClosingCollapseMode(TextEditor::TextBlockUserData::NoClosingCollapse);
blockData->setCollapseMode(TextEditor::TextBlockUserData::NoCollapse);
}
if (!m_currentBlockParentheses.isEmpty()) {
QTC_ASSERT(blockData, return);
int collapse = Parenthesis::collapseAtPos(m_currentBlockParentheses);
if (collapse >= 0) {
if (collapse == firstNonSpace)
blockData->setCollapseMode(TextEditor::TextBlockUserData::CollapseThis);
else
blockData->setCollapseMode(TextEditor::TextBlockUserData::CollapseAfter);
}
if (Parenthesis::hasClosingCollapse(m_currentBlockParentheses))
blockData->setClosingCollapseMode(TextEditor::TextBlockUserData::NoClosingCollapse);
}
void Highlighter::highlightBlock(const QString &text)
{
if (text.isEmpty() || !d->active || !d->spellCheckerFound) {
return;
}
if (!d->connected) {
connect(document(), SIGNAL(contentsChange(int,int,int)),
SLOT(contentsChange(int,int,int)));
d->connected = true;
}
QTextCursor cursor;
if (d->textEdit) {
cursor = d->textEdit->textCursor();
} else {
cursor = d->plainTextEdit->textCursor();
}
int index = cursor.position();
const int lengthPosition = text.length() - 1;
if ( index != lengthPosition ||
( lengthPosition > 0 && !text[lengthPosition-1].isLetter() ) ) {
LanguageCache* cache=dynamic_cast<LanguageCache*>(currentBlockUserData());
if (!cache) {
cache = new LanguageCache;
setCurrentBlockUserData(cache);
}
QStringRef sentence=&text;
d->tokenizer->setBuffer(sentence.toString());
int offset=sentence.position();
while (d->tokenizer->hasNext()) {
QStringRef word=d->tokenizer->next();
if (!d->tokenizer->isSpellcheckable()) continue;
++d->wordCount;
if (d->spellchecker->isMisspelled(word.toString())) {
++d->errorCount;
setMisspelled(word.position()+offset, word.length());
} else {
unsetMisspelled(word.position()+offset, word.length());
}
}
}
//QTimer::singleShot( 0, this, SLOT(checkWords()) );
setCurrentBlockState(0);
}
void SyntaxHighlighter::highlightBlockInSymbol(ScLexer & lexer)
{
int originalOffset = lexer.offset();
int tokenLength;
Token::Type tokenType = lexer.nextToken(tokenLength);
int range = lexer.offset() - originalOffset;
setFormat(originalOffset, range, mGlobals->format(SymbolFormat));
if (tokenType == Token::Unknown)
return;
Q_ASSERT(tokenType == Token::SymbolMark);
Token token(tokenType, lexer.offset() - 1, 1);
token.character = '\'';
TextBlockData *blockData = static_cast<TextBlockData*>(currentBlockUserData());
Q_ASSERT(blockData);
blockData->tokens.push_back( token );
}
void LuaHighlighter::highlightBlock(const QString &text)
{
setCurrentBlockState(BS_Dummy);
MyTextBlockUserData* p = static_cast<MyTextBlockUserData*>(currentBlockUserData());
if(p){
p->clear();
}else{
p = new MyTextBlockUserData();
setCurrentBlockUserData(p);
}
int offset = 0;
int prevState = previousBlockState();
//*
if (prevState != BS_Dummy && prevState < BS_LastState && prevState>0){
HighlightingRule prevRule = highlightingRules.at(prevState);
int len = matchBlockEnd(text, offset, prevRule);
setFormat(offset, len, prevRule);
offset += len;
}
//*/
//foreach (const HighlightingRule &rule, highlightingRules) {
//QRegExp expression(rule.pattern);
//int index = expression.indexIn(text, offset);
while(offset < text.length()){
HighlightingRule rule;
int matchedLength = 0;
int index = matchPatten(text,offset,rule,matchedLength);
while (index >= 0) {
int length = matchedLength;
if(rule.blockState != BS_Dummy){
length = matchBlockEnd(text, index+matchedLength, rule);
length += matchedLength;
}
setFormat(index, length, rule);
offset = index + length;
index = matchPatten(text,offset,rule,matchedLength);
}
if(index == -1)break;
}
}
void SyntaxHighlighter::highlightBlock(const QString& text)
{
TextBlockData *blockData = static_cast<TextBlockData*>(currentBlockUserData());
if(!blockData) {
blockData = new TextBlockData;
blockData->tokens.reserve(8);
setCurrentBlockUserData(blockData);
}
else {
blockData->tokens.clear();
}
int previousState = previousBlockState();
if (previousState == -1)
previousState = ScLexer::InCode;
ScLexer lexer( text, 0, previousState );
while (lexer.offset() < text.size()) {
switch (lexer.state()) {
case ScLexer::InCode:
highlightBlockInCode(lexer);
break;
case ScLexer::InString:
highlightBlockInString(lexer);
break;
case ScLexer::InSymbol:
highlightBlockInSymbol(lexer);
break;
default:
if(lexer.state() >= ScLexer::InComment)
highlightBlockInComment(lexer);
}
}
setCurrentBlockState( lexer.state() );
}
void KCCppHighlighter::stringHighlightBlock(const QString &text)
{
KCTextBlockData *data=static_cast<KCTextBlockData *>(currentBlockUserData());
for(auto i=data->getFirstQuotationInfo(),
l=data->getEndQuotationInfo();
i<l;
i++)
{
if(i->endPos == 0)
{
setFormat(i->beginPos,
text.length() - i->beginPos,
instance->getTextCharFormat(QString("string")));
}
else
{
setFormat(i->beginPos,
i->endPos - i->beginPos,
instance->getTextCharFormat(QString("string")));
}
}
}
void CppSyntaxHighlighter::highlightBlock(const QString &text)
{
// states
const int StateStandard = 0;
const int StateCommentStart1 = 1;
const int StateCCommentStart2 = 2;
const int StateCppCommentStart2 = 3;
const int StateCComment = 4;
const int StateCppComment = 5;
const int StateCCommentEnd1 = 6;
const int StateCCommentEnd2 = 7;
const int StateStringStart = 8;
const int StateString = 9;
const int StateStringEnd = 10;
const int StateString2Start = 11;
const int StateString2 = 12;
const int StateString2End = 13;
const int StateNumber = 14;
const int StatePreProcessor = 15;
// tokens
const int InputAlpha = 0;
const int InputNumber = 1;
const int InputAsterix = 2;
const int InputSlash = 3;
const int InputParen = 4;
const int InputSpace = 5;
const int InputHash = 6;
const int InputQuotation = 7;
const int InputApostrophe = 8;
const int InputSep = 9;
static const uchar table[16][10] = {
{ StateStandard, StateNumber, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateStandard
{ StateStandard, StateNumber, StateCCommentStart2, StateCppCommentStart2, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateCommentStart1
{ StateCComment, StateCComment, StateCCommentEnd1, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment }, // StateCCommentStart2
{ StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment }, // CppCommentStart2
{ StateCComment, StateCComment, StateCCommentEnd1, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment }, // StateCComment
{ StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment }, // StateCppComment
{ StateCComment, StateCComment, StateCCommentEnd1, StateCCommentEnd2, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment }, // StateCCommentEnd1
{ StateStandard, StateNumber, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateCCommentEnd2
{ StateString, StateString, StateString, StateString, StateString, StateString, StateString, StateStringEnd, StateString, StateString }, // StateStringStart
{ StateString, StateString, StateString, StateString, StateString, StateString, StateString, StateStringEnd, StateString, StateString }, // StateString
{ StateStandard, StateStandard, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateStringEnd
{ StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2End, StateString2 }, // StateString2Start
{ StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2End, StateString2 }, // StateString2
{ StateStandard, StateStandard, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateString2End
{ StateNumber, StateNumber, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateNumber
{ StatePreProcessor, StateStandard, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard } // StatePreProcessor
};
QString buffer;
QTextCharFormat emptyFormat;
int state = StateStandard;
const int previousState = previousBlockState();
if (previousState != -1)
state = previousState;
BlockData *blockData = static_cast<BlockData *>(currentBlockUserData());
if (blockData) {
blockData->parentheses.clear();
} else {
blockData = new BlockData;
setCurrentBlockUserData(blockData);
}
if (text.isEmpty()) {
setCurrentBlockState(previousState);
return;
}
int input = -1;
int i = 0;
bool lastWasBackSlash = false;
bool makeLastStandard = false;
static QString alphabeth = QString::fromLatin1("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
static QString mathChars = QString::fromLatin1("xXeE");
static QString numbers = QString::fromLatin1("0123456789");
bool questionMark = false;
bool resetLineState = true;
QChar lastChar;
QString firstWord;
forever {
QChar c = text.at(i);
if (lastWasBackSlash) {
input = InputSep;
} else {
switch (c.toAscii()) {
case '*':
input = InputAsterix;
break;
case '/':
input = InputSlash;
break;
case '(': case '[': case '{':
input = InputParen;
if (state == StateStandard
|| state == StateNumber
|| state == StatePreProcessor
|| state == StateCCommentEnd2
|| state == StateCCommentEnd1
|| state == StateString2End
|| state == StateStringEnd
)
blockData->parentheses << Parenthesis(Parenthesis::Open, c, i);
break;
case ')': case ']': case '}':
input = InputParen;
if (state == StateStandard
|| state == StateNumber
|| state == StatePreProcessor
|| state == StateCCommentEnd2
|| state == StateCCommentEnd1
|| state == StateString2End
|| state == StateStringEnd
) {
blockData->parentheses << Parenthesis(Parenthesis::Closed, c, i);
/* #####
if (c == '}') {
if (checkFunctionEnd(string, i))
resetLineState = false;
}
*/
}
break;
case '#':
input = InputHash;
break;
case '"':
input = InputQuotation;
break;
case '\'':
input = InputApostrophe;
break;
case ' ':
input = InputSpace;
if (firstWord == QLatin1String("function")
|| firstWord == QLatin1String("constructor")
|| firstWord == QLatin1String("class")
// || firstWord == QLatin1String("if")
// || firstWord == QLatin1String("for")
// || firstWord == QLatin1String("while")
// || firstWord == QLatin1String("else")
) {
// #### paragData->lineState = ParagData::FunctionStart;
resetLineState = false;
}
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case '0':
if (alphabeth.contains(lastChar)
&& (!mathChars.contains(lastChar) || !numbers.contains(text.at(i - 1)))) {
input = InputAlpha;
} else {
if (input == InputAlpha && numbers.contains(lastChar))
input = InputAlpha;
else
input = InputNumber;
}
break;
case ':': {
input = InputAlpha;
QChar nextChar = ' ';
if (i < text.length() - 1)
nextChar = text.at(i + 1);
if (state == StateStandard && !questionMark &&
lastChar != ':' && nextChar != ':' && lastChar.isLetter()) {
for (int j = 0; j < i; ++j) {
if (format(j) == emptyFormat)
setFormat(j, 1, labelFormat);
}
}
break;
}
default: {
if ( c != QLatin1Char('\t') )
firstWord += c;
const QString s = firstWord.simplified();
if ( s == QLatin1String("private")
|| s == QLatin1String("protected")
|| s == QLatin1String("public")
|| s == QLatin1String("static")
)
firstWord.clear();
if (!questionMark && c == QLatin1Char('?'))
questionMark = true;
if (c.isLetter() || c == QLatin1Char('_'))
input = InputAlpha;
else
input = InputSep;
} break;
}
}
lastWasBackSlash = !lastWasBackSlash && c == QLatin1Char('\\');
if (input == InputAlpha)
buffer += c;
state = table[state][input];
switch (state) {
case StateStandard: {
setFormat(i, 1, emptyFormat);
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
if (!buffer.isEmpty() && input != InputAlpha ) {
highlightKeyword(i, buffer);
buffer.clear();
}
} break;
case StateCommentStart1:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = true;
buffer.clear();
break;
case StateCCommentStart2:
setFormat(i - 1, 2, commentFormat);
makeLastStandard = false;
buffer.clear();
break;
case StateCppCommentStart2:
setFormat(i - 1, 2, commentFormat);
makeLastStandard = false;
buffer.clear();
break;
case StateCComment:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateCppComment:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateCCommentEnd1:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateCCommentEnd2:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateStringStart:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateString:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, stringFormat);
buffer.clear();
break;
case StateStringEnd:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateString2Start:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateString2:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, stringFormat);
buffer.clear();
break;
case StateString2End:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateNumber:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat( i, 1, numberFormat);
buffer.clear();
break;
case StatePreProcessor:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, preProcessorFormat);
buffer = QString::null;
break;
}
lastChar = c;
i++;
if (i >= text.length())
break;
}
highlightKeyword(text.length(), buffer);
/*
if (resetLineState)
paragData->lineState = ParagData::InFunction;
string->setExtraData( paragData );
*/
if (state == StateCComment
|| state == StateCCommentEnd1
|| state == StateCCommentStart2
) {
state = StateCComment;
} else if (state == StateString) {
state = StateString;
} else if (state == StateString2) {
state = StateString2;
} else {
state = StateStandard;
}
if (blockData->parenthesisMatchStart != -1) {
for (int pos = blockData->parenthesisMatchStart;
pos < blockData->parenthesisMatchEnd; ++pos) {
QTextCharFormat fmt = format(pos);
fmt.merge(blockData->parenthesisMatchingFormat);
setFormat(pos, 1, fmt);
}
}
if (blockData->errorMarkerFormat.hasProperty(ErrorMarkerPropertyId)) {
for (int i = 0; i < text.length(); ++i) {
QTextCharFormat fmt = format(i);
fmt.merge(blockData->errorMarkerFormat);
setFormat(i, 1, fmt);
}
}
setCurrentBlockState(state);
}
void Highlighter::highlightBlock( const QString &ctext ){
QString text=ctext;
int i=0,n=text.length();
while( i<n && text[i]<=' ' ) ++i;
if( _editor->isMonkey() ){
//
// handle monkey block comments
//
int st=previousBlockState();
int blkst=st;
if( i<n && text[i]=='#' ){
int i0=i+1;
while( i0<n && text[i0]<=' ' ) ++i0;
int i1=i0;
while( i1<n && isIdent(text[i1]) ) ++i1;
QString t=text.mid( i0,i1-i0 ).toLower();
if( t=="rem" ){
blkst=++st;
}else if( t=="if" ){
if( st>-1 ) blkst=++st;
}else if( t=="end" || t=="endif" ){
if( st>-1) blkst=st-1;
}
}
setCurrentBlockState( blkst );
if( st>-1 ){
setFormat( 0,text.length(),_commentsColor );
setCurrentBlockUserData( 0 );
return;
}
}
if( !_editor->isCode() ){
setFormat( 0,text.length(),_defaultColor );
setCurrentBlockUserData( 0 );
return;
}
int indent=i;
text=text.mid(i);
int colst=0;
QColor curcol=_defaultColor;
QVector<QString> tokes;
for(;;){
QColor col=curcol;
QString t=parseToke( text,col );
if( t.isEmpty() ) break;
if( t[0]>' ' ) tokes.push_back( t );
if( col!=curcol ){
setFormat( colst,i-colst,curcol );
curcol=col;
colst=i;
}
i+=t.length();
}
if( colst<n ) setFormat( colst,n-colst,curcol );
if( _editor->isMonkey() ){
//
//Update user block data for code tree.
//
BlockData *data=0;
QString decl=tokes.size()>0 ? tokes[0].toLower() : "";
QString ident=tokes.size()>1 ? tokes[1] : "";
if( (decl=="class" || decl=="interface" || decl=="method" || decl=="function") && !ident.isEmpty() ){
QTextBlock block=currentBlock();
data=dynamic_cast<BlockData*>( currentBlockUserData() );
if( data && data->block()==block && data->decl()==decl && data->ident()==ident && data->indent()==indent ){
}else{
data=new BlockData( this,block,decl,ident,indent );
setCurrentBlockUserData( data );
insert( data );
}
}else{
setCurrentBlockUserData( 0 );
}
}
}
void KCCppHighlighter::conmmentHighlightBlock(const QString &text)
{
QRegExp startExpression("/\\*");
QRegExp endExpression("\\*/");
KCTextBlockData *data=static_cast<KCTextBlockData *>(currentBlockUserData());
setCurrentBlockState(0);
int startIndex=0;
if(previousBlockState() != 1)
{
startIndex=text.indexOf(startExpression);
}
bool searchNext;
while(startIndex > -1)
{
searchNext=false;
if(data->getLineCommentPos()>-1 &&
startIndex > data->getLineCommentPos())
{
/*
* Here means: begin char is no use!
*/
startIndex=text.indexOf(startExpression, startIndex+1);
continue;
}
for(auto i=data->getFirstQuotationInfo(),
l=data->getEndQuotationInfo();
i<l;
i++)
{
if(startIndex > i->beginPos && startIndex < i->endPos)
{
startIndex=text.indexOf(startExpression, i->endPos+1);
searchNext=true;
break;
}
}
if(searchNext)
{
continue;
}
int endIndex = text.indexOf(endExpression, startIndex);
while(searchNext)
{
searchNext=false;
for(auto i=data->getFirstQuotationInfo(),
l=data->getEndQuotationInfo();
i<l;
i++)
{
if(endIndex > i->beginPos && endIndex < i->endPos)
{
endIndex=text.indexOf(endExpression, i->endPos+1);
searchNext=true;
break;
}
}
}
int conmmentLength;
if(endIndex == -1)
{
setCurrentBlockState(1);
conmmentLength = text.length() - startIndex;
}
else
{
conmmentLength = endIndex - startIndex + endExpression.matchedLength();
}
setFormat(startIndex,conmmentLength,instance->getTextCharFormat("comment"));
startIndex = text.indexOf(startExpression, startIndex+conmmentLength);
}
}
void KCCppHighlighter::KCHighlightBlock(const QString &text)
{
for(int i=0; i<rules.size(); i++)
{
QRegularExpressionMatchIterator matchIterator=rules[i].regexp.globalMatch(
text);
while(matchIterator.hasNext())
{
QRegularExpressionMatch match=matchIterator.next();
setFormat(match.capturedStart(),
match.capturedLength(),
instance->getTextCharFormat(rules[i].type_name));
//QTextCharFormat());
}
}
KCTextBlockData *data=static_cast<KCTextBlockData *>(currentBlockUserData());
Q_ASSERT(data!=NULL);
QTextBlock prevBlock=currentBlock().previous();
int baseLevel=0;
bool levelUp=false, levelDown=false;
if(prevBlock.isValid())
{
KCTextBlockData *prevData=static_cast<KCTextBlockData *>(prevBlock.userData());
Q_ASSERT(prevData!=NULL);
baseLevel=prevData->getCodeLevel();
for(auto i=prevData->getFirstParenthesesInfo(),
l=prevData->getEndParenthesesInfo();
i<l;
i++)
{
if(i->character == '{')
{
baseLevel++;
levelUp=true;
}
else if(i->character == '}')
{
baseLevel--;
levelDown=true;
}
}
prevData->setCodeLevelUp(levelUp);
prevData->setCodeLevelDown(levelDown);
}
data->setCodeLevel(baseLevel);
//Highlight single line comment
if(data->getLineCommentPos()!=-1)
{
setFormat(data->getLineCommentPos(),
text.length()-data->getLineCommentPos(),
instance->getTextCharFormat("comment"));
}
stringHighlightBlock(text);
conmmentHighlightBlock(text);
}
void Highlighter::highlightBlock(const QString &text)
{
if (text.isEmpty() || !d->active || !d->spellCheckerFound) {
return;
}
if (!d->connected) {
connect(document(), SIGNAL(contentsChange(int,int,int)),
SLOT(contentsChange(int,int,int)));
d->connected = true;
}
QTextCursor cursor;
if (d->textEdit) {
cursor = d->textEdit->textCursor();
} else {
cursor = d->plainTextEdit->textCursor();
}
int index = cursor.position();
const int lengthPosition = text.length() - 1;
if ( index != lengthPosition ||
( lengthPosition > 0 && !text[lengthPosition-1].isLetter() ) ) {
d->languageFilter->setBuffer(text);
LanguageCache* cache=dynamic_cast<LanguageCache*>(currentBlockUserData());
if (!cache) {
cache = new LanguageCache;
setCurrentBlockUserData(cache);
}
while (d->languageFilter->hasNext()) {
QStringRef sentence=d->languageFilter->next();
if (d->spellchecker->testAttribute(Speller::AutoDetectLanguage)) {
QString lang;
QPair<int,int> spos=QPair<int,int>(sentence.position(),sentence.length());
// try cache first
if (cache->languages.contains(spos)) {
lang=cache->languages.value(spos);
} else {
lang=d->languageFilter->language();
if (!d->languageFilter->isSpellcheckable()) lang.clear();
cache->languages[spos]=lang;
}
if (lang.isEmpty()) continue;
d->spellchecker->setLanguage(lang);
}
d->tokenizer->setBuffer(sentence.toString());
int offset=sentence.position();
while (d->tokenizer->hasNext()) {
QStringRef word=d->tokenizer->next();
if (!d->tokenizer->isSpellcheckable()) continue;
++d->wordCount;
if (d->spellchecker->isMisspelled(word.toString())) {
++d->errorCount;
setMisspelled(word.position()+offset, word.length());
} else {
unsetMisspelled(word.position()+offset, word.length());
}
}
}
}
//QTimer::singleShot( 0, this, SLOT(checkWords()) );
setCurrentBlockState(0);
}
void SyntaxHighlighter::highlightBlockInCode(ScLexer & lexer)
{
TextBlockData *blockData = static_cast<TextBlockData*>(currentBlockUserData());
Q_ASSERT(blockData);
const QTextCharFormat * formats = mGlobals->formats();
do {
int tokenPosition = lexer.offset();
int tokenLength;
Token::Type tokenType = lexer.nextToken(tokenLength);
switch (tokenType)
{
case Token::WhiteSpace:
setFormat(tokenPosition, tokenLength, formats[WhitespaceFormat]);
break;
case Token::Class:
setFormat(tokenPosition, tokenLength, formats[ClassFormat]);
break;
case Token::Builtin:
setFormat(tokenPosition, tokenLength, formats[BuiltinFormat]);
break;
case Token::Primitive:
setFormat(tokenPosition, tokenLength, formats[PrimitiveFormat]);
break;
case Token::Keyword:
setFormat(tokenPosition, tokenLength, formats[KeywordFormat]);
break;
case Token::Symbol:
setFormat(tokenPosition, tokenLength, formats[SymbolFormat]);
break;
case Token::SymbolArg:
// Don't highlight the trailing ':'
setFormat(tokenPosition, tokenLength-1, formats[SymbolFormat]);
break;
case Token::EnvVar:
setFormat(tokenPosition, tokenLength, formats[EnvVarFormat]);
break;
case Token::Char:
setFormat(tokenPosition, tokenLength, formats[CharFormat]);
break;
case Token::Float:
case Token::HexInt:
case Token::RadixFloat:
setFormat(tokenPosition, tokenLength, formats[NumberFormat]);
break;
case Token::SingleLineComment:
setFormat(tokenPosition, tokenLength, formats[CommentFormat]);
break;
case Token::MultiLineCommentStart:
setFormat(tokenPosition, tokenLength, formats[CommentFormat]);
break;
case Token::StringMark:
setFormat(tokenPosition, tokenLength, formats[StringFormat]);
break;
case Token::SymbolMark:
setFormat(tokenPosition, tokenLength, formats[SymbolFormat]);
break;
default:
;
}
if ( (tokenType != Token::WhiteSpace) &&
(tokenType != Token::SingleLineComment) &&
(tokenType != Token::MultiLineCommentStart) )
{
Token token(tokenType, tokenPosition, tokenLength);
if (token.length == 1)
token.character = lexer.text()[tokenPosition].toLatin1();
blockData->tokens.push_back( token );
}
} while (lexer.state() == ScLexer::InCode && lexer.offset() < lexer.text().size());
}
