editors/sc-ide/widgets/code_editor/highlighter.cpp

   1 /*
   2     SuperCollider Qt IDE
   3     Copyright (c) 2012 Jakob Leben & Tim Blechmann
   4     http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21 #include <cassert>
  22 #include <algorithm>
  23
  24 #include "highlighter.hpp"
  25 #include "../../core/main.hpp"
  26 #include "../../core/settings/manager.hpp"
  27
  28 #include <QApplication>
  29
  30 namespace ScIDE {
  31
  32 SyntaxHighlighterGlobals * SyntaxHighlighterGlobals::mInstance = 0;
  33
  34 SyntaxHighlighterGlobals::SyntaxHighlighterGlobals( Main *main, Settings::Manager * settings ):
  35     QObject(main)
  36 {
  37     Q_ASSERT(mInstance == 0);
  38     mInstance = this;
  39
  40     initSyntaxRules();
  41
  42     // initialize formats from settings:
  43     applySettings(settings);
  44
  45     connect(main, SIGNAL(applySettingsRequest(Settings::Manager*)),
  46             this, SLOT(applySettings(Settings::Manager*)));
  47 }
  48
  49 void SyntaxHighlighterGlobals::initSyntaxRules()
  50 {
  51     /* NOTE:
  52
  53     The highlighting algorithm demands that all regexps
  54     start with a caret "^", to only match at beginning of string.
  55
  56     Order is important:
  57     -- floatRegexp is subset of radixFloatRegex -> must come later
  58     -- classRegexp and primitiveRegexp are subsets of symbolArgRegexp -> must come later
  59
  60     */
  61
  62     mInCodeRules << SyntaxRule( Token::WhiteSpace, "^\\s+" );
  63
  64     initKeywords();
  65     initBuiltins();
  66
  67     mInCodeRules << SyntaxRule( Token::SymbolArg, "^\\b[A-Za-z_]\\w*\\:" );
  68
  69     mInCodeRules << SyntaxRule( Token::Name, "^[a-z]\\w*" );
  70
  71     mInCodeRules << SyntaxRule( Token::Class, "^\\b[A-Z]\\w*" );
  72
  73     mInCodeRules << SyntaxRule( Token::Primitive, "^\\b_\\w+" );
  74
  75     mInCodeRules << SyntaxRule( Token::Symbol, "^(\\\\\\w*|\\'([^\\'\\\\]*(\\\\.[^\\'\\\\]*)*)\\')" );
  76
  77     mInCodeRules << SyntaxRule( Token::Char, "^\\$\\\\?." );
  78
  79     mInCodeRules << SyntaxRule( Token::String, "^\"([^\"\\\\]*(\\\\.[^\"\\\\]*)*)\"" );
  80
  81     mInCodeRules << SyntaxRule( Token::EnvVar, "^~\\w+" );
  82
  83     mInCodeRules << SyntaxRule( Token::RadixFloat, "^\\b\\d+r[0-9a-zA-Z]*(\\.[0-9A-Z]*)?" );
  84
  85     // do not include leading "-" in float highlighting, as there's no clear
  86     // rule whether it is not rather a binary operator
  87     mInCodeRules << SyntaxRule( Token::Float, "^\\b((\\d+(\\.\\d+)?([eE][-+]?\\d+)?(pi)?)|pi)" );
  88
  89     mInCodeRules << SyntaxRule( Token::HexInt, "^\\b0(x|X)(\\d|[a-f]|[A-F])+" );
  90
  91     mInCodeRules << SyntaxRule( Token::SingleLineComment, "^//[^\r\n]*" );
  92
  93     mInCodeRules << SyntaxRule( Token::MultiLineCommentStart, "^/\\*" );
  94
  95     mInSymbolRegexp.setPattern("([^\'\\\\]*(\\\\.[^\'\\\\]*)*)");
  96     mInStringRegexp.setPattern("([^\"\\\\]*(\\\\.[^\"\\\\]*)*)");
  97 }
  98
  99 void SyntaxHighlighterGlobals::initKeywords()
 100 {
 101     QStringList keywords;
 102     keywords << "arg"
 103              << "classvar"
 104              << "const"
 105              << "super"
 106              << "this"
 107              << "var";
 108
 109     QString keywordPattern = QString("^\\b(%1)\\b").arg(keywords.join("|"));
 110     mInCodeRules << SyntaxRule(Token::Keyword, keywordPattern);
 111 }
 112
 113 void SyntaxHighlighterGlobals::initBuiltins()
 114 {
 115     QStringList builtins;
 116     builtins << "false"
 117              << "inf"
 118              << "nil"
 119              << "true"
 120              << "thisFunction"
 121              << "thisFunctionDef"
 122              << "thisMethod"
 123              << "thisProcess"
 124              << "thisThread"
 125              << "currentEnvironment"
 126              << "topEnvironment"
 127                 ;
 128
 129     QString builtinsPattern = QString("^\\b(%1)\\b").arg(builtins.join("|"));
 130     mInCodeRules << SyntaxRule(Token::Builtin, builtinsPattern);
 131 }
 132
 133 void SyntaxHighlighterGlobals::applySettings( Settings::Manager *s )
 134 {
 135     QString key("IDE/editor/highlighting");
 136     applySettings( s, key + "/normal", PlainFormat );
 137     applySettings( s, key + "/keyword", KeywordFormat );
 138     applySettings( s, key + "/built-in", BuiltinFormat );
 139     applySettings( s, key + "/primitive", PrimitiveFormat );
 140     applySettings( s, key + "/class", ClassFormat );
 141     applySettings( s, key + "/number", NumberFormat );
 142     applySettings( s, key + "/symbol", SymbolFormat );
 143     applySettings( s, key + "/env-var", EnvVarFormat );
 144     applySettings( s, key + "/string", StringFormat );
 145     applySettings( s, key + "/char", CharFormat );
 146     applySettings( s, key + "/comment", CommentFormat );
 147
 148     Q_EMIT(syntaxFormatsChanged());
 149 }
 150
 151 void SyntaxHighlighterGlobals::applySettings( Settings::Manager *s, const QString &key, SyntaxFormat type )
 152 {
 153     mFormats[type] = s->value(key).value<QTextCharFormat>();
 154 }
 155
 156 SyntaxHighlighter::SyntaxHighlighter(QTextDocument *parent):
 157     QSyntaxHighlighter( parent )
 158 {
 159     mGlobals = SyntaxHighlighterGlobals::instance();
 160
 161     connect(mGlobals, SIGNAL(syntaxFormatsChanged()), this, SLOT(rehighlight()));
 162 }
 163
 164 Token::Type SyntaxHighlighter::findMatchingRule (const QString& text, int& currentIndex, int& lengthOfMatch)
 165 {
 166     int matchLength = -1;
 167     Token::Type matchType = Token::Unknown;
 168
 169     QVector<SyntaxRule>::const_iterator it  = mGlobals->mInCodeRules.constBegin();
 170     QVector<SyntaxRule>::const_iterator end = mGlobals->mInCodeRules.constEnd();
 171
 172     for (; it != end; ++it) {
 173         SyntaxRule const & rule = *it;
 174         int matchIndex = rule.expr.indexIn(text, currentIndex, QRegExp::CaretAtOffset);
 175         // a guard to ensure all regexps match only at beginning of string:
 176         assert(matchIndex <= currentIndex);
 177         if (matchIndex != -1) {
 178             matchType = rule.type;
 179             matchLength = rule.expr.matchedLength();
 180             break;
 181         }
 182     }
 183
 184     lengthOfMatch = matchType == Token::Unknown ? 0 : matchLength;
 185     return matchType;
 186 }
 187
 188 void SyntaxHighlighter::highlightBlockInCode(const QString& text, int & currentIndex, int & currentState)
 189 {
 190     TextBlockData *blockData = static_cast<TextBlockData*>(currentBlockUserData());
 191     Q_ASSERT(blockData);
 192
 193     const QTextCharFormat * formats = mGlobals->formats();
 194
 195     do {
 196         static QString openingBrackets("({[");
 197         static QString closingBrackets(")}]");
 198         static QChar stringStart('\"');
 199         static QChar symbolStart('\'');
 200
 201         QChar currentChar = text[currentIndex];
 202
 203         if (currentChar == stringStart) {
 204             currentState = inString;
 205             setFormat(currentIndex, 1, formats[StringFormat]);
 206             blockData->tokens.push_back( Token(Token::String, currentIndex) );
 207             currentIndex += 1;
 208             return;
 209         }
 210
 211         if (currentChar == symbolStart) {
 212             currentState = inSymbol;
 213             setFormat(currentIndex, 1, formats[SymbolFormat]);
 214             blockData->tokens.push_back( Token(Token::Symbol, currentIndex) );
 215             currentIndex += 1;
 216             return;
 217         }
 218
 219         if (openingBrackets.contains(currentChar)) {
 220             blockData->tokens.push_back(
 221                 Token( Token::OpeningBracket,
 222                        currentIndex, 1,
 223                        currentChar.toAscii() ) );
 224             ++currentIndex;
 225             continue;
 226         }
 227
 228         if (closingBrackets.contains(currentChar)) {
 229             blockData->tokens.push_back(
 230                 Token( Token::ClosingBracket,
 231                        currentIndex, 1,
 232                        currentChar.toAscii() ) );
 233             ++currentIndex;
 234             continue;
 235         }
 236
 237         int lenghtOfMatch;
 238         Token::Type tokenType = findMatchingRule(text, currentIndex, lenghtOfMatch);
 239
 240         switch (tokenType)
 241         {
 242         case Token::WhiteSpace:
 243             // avoid inserting a token
 244             currentIndex += lenghtOfMatch;
 245             continue;
 246
 247         case Token::Class:
 248             setFormat(currentIndex, lenghtOfMatch, formats[ClassFormat]);
 249             break;
 250
 251         case Token::Builtin:
 252             setFormat(currentIndex, lenghtOfMatch, formats[BuiltinFormat]);
 253             break;
 254
 255         case Token::Primitive:
 256             setFormat(currentIndex, lenghtOfMatch, formats[PrimitiveFormat]);
 257             break;
 258
 259         case Token::Keyword:
 260             setFormat(currentIndex, lenghtOfMatch, formats[KeywordFormat]);
 261             break;
 262
 263         case Token::Symbol:
 264             setFormat(currentIndex, lenghtOfMatch, formats[SymbolFormat]);
 265             break;
 266
 267         case Token::SymbolArg:
 268             // Omit the trailing ":" that was included in the regexp:
 269             setFormat(currentIndex, lenghtOfMatch-1, formats[SymbolFormat]);
 270             break;
 271
 272         case Token::EnvVar:
 273             setFormat(currentIndex, lenghtOfMatch, formats[EnvVarFormat]);
 274             break;
 275
 276         case Token::String:
 277             setFormat(currentIndex, lenghtOfMatch, formats[StringFormat]);
 278             break;
 279
 280         case Token::Char:
 281             setFormat(currentIndex, lenghtOfMatch, formats[CharFormat]);
 282             break;
 283
 284         case Token::Float:
 285         case Token::HexInt:
 286         case Token::RadixFloat:
 287             setFormat(currentIndex, lenghtOfMatch, formats[NumberFormat]);
 288             break;
 289
 290         case Token::SingleLineComment:
 291             setFormat(currentIndex, lenghtOfMatch, formats[CommentFormat]);
 292             currentIndex += lenghtOfMatch;
 293             continue;
 294
 295         case Token::MultiLineCommentStart:
 296             setFormat(currentIndex, lenghtOfMatch, formats[CommentFormat]);
 297             currentIndex += lenghtOfMatch;
 298             currentState = inComment;
 299             return;
 300
 301         case Token::Unknown:
 302             blockData->tokens.push_back( Token(Token::Unknown, currentIndex, 1, currentChar.toAscii()) );
 303             currentIndex += 1;
 304             continue;
 305
 306         default:
 307             ;
 308         }
 309
 310         blockData->tokens.push_back( Token(tokenType, currentIndex, lenghtOfMatch) );
 311
 312         currentIndex += lenghtOfMatch;
 313
 314     } while (currentIndex < text.size());
 315 }
 316
 317 void SyntaxHighlighter::highlightBlockInString(const QString& text, int& currentIndex, int& currentState)
 318 {
 319     const QRegExp &expr = mGlobals->mInStringRegexp;
 320     int matchIndex = expr.indexIn(text, currentIndex);
 321     if (matchIndex == -1)
 322         assert(false);
 323
 324     int matchLength = expr.matchedLength();
 325     setFormat(currentIndex, matchLength, mGlobals->format(StringFormat));
 326     currentIndex += matchLength;
 327     if (currentIndex == text.size()) {
 328         // end of block
 329         currentState = inString;
 330         return;
 331     }
 332
 333     static const QChar endOfString('\"');
 334     if (text[currentIndex] == endOfString)
 335         currentState = inCode;
 336
 337     setFormat(currentIndex, 1, mGlobals->format(StringFormat));
 338     ++currentIndex;
 339     return;
 340 }
 341
 342 void SyntaxHighlighter::highlightBlockInSymbol(const QString& text, int& currentIndex, int& currentState)
 343 {
 344     const QRegExp &expr = mGlobals->mInSymbolRegexp;
 345     int matchIndex = expr.indexIn(text, currentIndex);
 346     if (matchIndex == -1)
 347         assert(false);
 348
 349     int matchLength = expr.matchedLength();
 350     setFormat(currentIndex, matchLength, mGlobals->format(SymbolFormat));
 351     currentIndex += matchLength;
 352     if (currentIndex == text.size()) {
 353         // end of block
 354         currentState = inSymbol;
 355         return;
 356     }
 357
 358     static const QChar endOfSymbol('\'');
 359     if (text[currentIndex] == endOfSymbol)
 360         currentState = inCode;
 361
 362     setFormat(currentIndex, 1, mGlobals->format(SymbolFormat));
 363     ++currentIndex;
 364     return;
 365 }
 366
 367 void SyntaxHighlighter::highlightBlockInComment(const QString& text, int& currentIndex, int& currentState)
 368 {
 369     int index = currentIndex;
 370     int maxIndex = text.size() - 1;
 371
 372     static const QString commentStart("/*");
 373     static const QString commentEnd("*/");
 374
 375     int commentStartIndex = -2;
 376     int commentEndIndex   = -2;
 377
 378     while(index < maxIndex) {
 379         if ((commentStartIndex == -2) || (commentStartIndex < index))
 380             if (commentStartIndex != -1)
 381                 commentStartIndex = text.indexOf(commentStart, index);
 382
 383         if ((commentEndIndex == -2) || (commentEndIndex < index))
 384             if (commentEndIndex != -1)
 385                 commentEndIndex   = text.indexOf(commentEnd, index);
 386
 387         if (commentStartIndex == -1) {
 388             if (commentEndIndex == -1) {
 389                 index = maxIndex;
 390             } else {
 391                 index = commentEndIndex + 2;
 392                 --currentState;
 393             }
 394         } else {
 395             if (commentEndIndex == -1) {
 396                 index = commentStartIndex + 2;
 397                 ++currentState;
 398             } else {
 399                 if (commentStartIndex < commentEndIndex) {
 400                     index = commentStartIndex + 2;
 401                     ++currentState;
 402                 } else {
 403                     index = commentEndIndex + 2;
 404                     --currentState;
 405                 }
 406             }
 407         }
 408         if (currentState < inComment) {
 409             currentState = inCode;
 410             break;
 411         }
 412     }
 413
 414     if(currentState == inCode) {
 415         setFormat(currentIndex, index - currentIndex, mGlobals->format(CommentFormat));
 416         currentIndex = index;
 417     }
 418     else {
 419         setFormat(currentIndex, text.size() - currentIndex, mGlobals->format(CommentFormat));
 420         currentIndex = text.size();
 421     }
 422
 423     return;
 424 }
 425
 426 void SyntaxHighlighter::highlightBlock(const QString& text)
 427 {
 428     int currentIndex = 0;
 429
 430     int currentState = previousBlockState();
 431     if (currentState == -1)
 432         currentState = 0;
 433
 434     TextBlockData *blockData = static_cast<TextBlockData*>(currentBlockUserData());
 435     if(!blockData) {
 436         blockData = new TextBlockData;
 437         blockData->tokens.reserve(8);
 438         setCurrentBlockUserData(blockData);
 439     }
 440     else {
 441         blockData->tokens.clear();
 442     }
 443
 444     while (currentIndex < text.size()) {
 445         switch (currentState) {
 446         case inCode:
 447             highlightBlockInCode(text, currentIndex, currentState);
 448             break;
 449
 450         case inString:
 451             highlightBlockInString(text, currentIndex, currentState);
 452             break;
 453
 454         case inSymbol:
 455             highlightBlockInSymbol(text, currentIndex, currentState);
 456             break;
 457
 458         default:
 459             if(currentState >= inComment)
 460                 highlightBlockInComment(text, currentIndex, currentState);
 461         }
 462     }
 463     setCurrentBlockState(currentState);
 464 }
 465
 466 }