[geany/geany] 788a57: Merge branch 'scintilla-update'

Branch: refs/heads/master Author: Colomban Wendling ban@herbesfolles.org Committer: Colomban Wendling ban@herbesfolles.org Date: Wed, 22 May 2013 01:38:38 UTC Commit: 788a57f6fcf6bdb152847aedfaaf09aadc7cce43 https://github.com/geany/geany/commit/788a57f6fcf6bdb152847aedfaaf09aadc7cce...

Log Message: ----------- Merge branch 'scintilla-update'

Modified Paths: -------------- data/filetypes.c data/filetypes.haskell scintilla/gtk/PlatGTK.cxx scintilla/gtk/ScintillaGTK.cxx scintilla/include/SciLexer.h scintilla/include/Scintilla.h scintilla/include/Scintilla.iface scintilla/lexers/LexCPP.cxx scintilla/lexers/LexHaskell.cxx scintilla/lexers/LexLaTeX.cxx scintilla/lexers/LexOthers.cxx scintilla/lexlib/LexerModule.cxx scintilla/lexlib/PropSetSimple.cxx scintilla/lexlib/PropSetSimple.h scintilla/lexlib/StyleContext.h scintilla/lexlib/WordList.cxx scintilla/lexlib/WordList.h scintilla/scintilla_changes.patch scintilla/src/CallTip.cxx scintilla/src/CallTip.h scintilla/src/CellBuffer.cxx scintilla/src/CellBuffer.h scintilla/src/ContractionState.cxx scintilla/src/Decoration.cxx scintilla/src/Document.cxx scintilla/src/Document.h scintilla/src/Editor.cxx scintilla/src/Editor.h scintilla/src/Indicator.cxx scintilla/src/KeyMap.cxx scintilla/src/KeyMap.h scintilla/src/PerLine.cxx scintilla/src/PerLine.h scintilla/src/PositionCache.cxx scintilla/src/PositionCache.h scintilla/src/RESearch.cxx scintilla/src/RESearch.h scintilla/src/RunStyles.cxx scintilla/src/RunStyles.h scintilla/src/Selection.cxx scintilla/src/SplitVector.h scintilla/src/Style.cxx scintilla/src/Style.h scintilla/src/ViewStyle.cxx scintilla/src/ViewStyle.h scintilla/src/XPM.cxx scintilla/src/XPM.h scintilla/version.txt src/highlighting.c src/highlightingmappings.h

Modified: data/filetypes.c 1 files changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -6,6 +6,7 @@ commentline=comment_line commentdoc=comment_doc preprocessorcomment=comment +preprocessorcommentdoc=comment_doc number=number_1 word=keyword_1 word2=keyword_2

Modified: data/filetypes.haskell 4 files changed, 4 insertions(+), 0 deletions(-) =================================================================== @@ -20,6 +20,10 @@ module=function data=number_2 pragma=preprocessor preprocessor=preprocessor +stringeol=string_eol +reserved_operator=operator +literate_comment=comment +literate_codedelim=other

[keywords] # all items must be in one line

Modified: scintilla/gtk/PlatGTK.cxx 122 files changed, 58 insertions(+), 64 deletions(-) =================================================================== @@ -9,6 +9,7 @@ #include <stddef.h> #include <math.h>

+#include <string> #include <vector> #include <map>

@@ -259,6 +260,7 @@ class FontCached : Font { public: static FontID FindOrCreate(const FontParameters &fp); static void ReleaseId(FontID fid_); + static void ReleaseAll(); };

FontCached *FontCached::first = 0; @@ -299,11 +301,9 @@ FontID FontCached::FindOrCreate(const FontParameters &fp) { } if (ret == 0) { FontCached *fc = new FontCached(fp); - if (fc) { - fc->next = first; - first = fc; - ret = fc->fid; - } + fc->next = first; + first = fc; + ret = fc->fid; } FontMutexUnlock(); return ret; @@ -328,6 +328,12 @@ void FontCached::ReleaseId(FontID fid_) { FontMutexUnlock(); }

+void FontCached::ReleaseAll() { + while (first) { + ReleaseId(first->GetID()); + } +} + FontID FontCached::CreateNewFont(const FontParameters &fp) { PangoFontDescription *pfd = pango_font_description_new(); if (pfd) { @@ -831,8 +837,8 @@ void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) { } }

-char *UTF8FromLatin1(const char *s, int &len) { - char *utfForm = new char[len*2+1]; +std::string UTF8FromLatin1(const char *s, int len) { + std::string utfForm(len*2 + 1, '\0'); size_t lenU = 0; for (int i=0;i<len;i++) { unsigned int uch = static_cast<unsigned char>(s[i]); @@ -843,27 +849,26 @@ char *UTF8FromLatin1(const char *s, int &len) { utfForm[lenU++] = static_cast<char>(0x80 | (uch & 0x3f)); } } - utfForm[lenU] = '\0'; - len = lenU; + utfForm.resize(lenU); return utfForm; }

-static char *UTF8FromIconv(const Converter &conv, const char *s, int &len) { +static std::string UTF8FromIconv(const Converter &conv, const char *s, int len) { if (conv) { - char *utfForm = new char[len*3+1]; + std::string utfForm(len*3+1, '\0'); char *pin = const_cast<char *>(s); size_t inLeft = len; - char *pout = utfForm; + char *putf = &utfForm[0]; + char *pout = putf; size_t outLeft = len*3+1; size_t conversions = conv.Convert(&pin, &inLeft, &pout, &outLeft); if (conversions != ((size_t)(-1))) { *pout = '\0'; - len = pout - utfForm; + utfForm.resize(pout - putf); return utfForm; } - delete []utfForm; } - return 0; + return std::string(); }

// Work out how many bytes are in a character by trying to convert using iconv, @@ -901,18 +906,16 @@ void SurfaceImpl::DrawTextBase(PRectangle rc, Font &font_, XYPOSITION ybase, con if (context) { XYPOSITION xText = rc.left; if (PFont(font_)->pfd) { - char *utfForm = 0; + std::string utfForm; if (et == UTF8) { pango_layout_set_text(layout, s, len); } else { - if (!utfForm) { - SetConverter(PFont(font_)->characterSet); - utfForm = UTF8FromIconv(conv, s, len); - } - if (!utfForm) { // iconv failed so treat as Latin1 + SetConverter(PFont(font_)->characterSet); + utfForm = UTF8FromIconv(conv, s, len); + if (utfForm.empty()) { // iconv failed so treat as Latin1 utfForm = UTF8FromLatin1(s, len); } - pango_layout_set_text(layout, utfForm, len); + pango_layout_set_text(layout, utfForm.c_str(), utfForm.length()); } pango_layout_set_font_description(layout, PFont(font_)->pfd); pango_cairo_update_layout(context, layout); @@ -923,7 +926,6 @@ void SurfaceImpl::DrawTextBase(PRectangle rc, Font &font_, XYPOSITION ybase, con #endif cairo_move_to(context, xText, ybase); pango_cairo_show_layout_line(context, pll); - delete []utfForm; } } } @@ -1020,20 +1022,20 @@ void SurfaceImpl::MeasureWidths(Font &font_, const char *s, int len, XYPOSITION int positionsCalculated = 0; if (et == dbcs) { SetConverter(PFont(font_)->characterSet); - char *utfForm = UTF8FromIconv(conv, s, len); - if (utfForm) { + std::string utfForm = UTF8FromIconv(conv, s, len); + if (!utfForm.empty()) { // Convert to UTF-8 so can ask Pango for widths, then // Loop through UTF-8 and DBCS forms, taking account of different // character byte lengths. Converter convMeasure("UCS-2", CharacterSetID(characterSet), false); - pango_layout_set_text(layout, utfForm, strlen(utfForm)); + pango_layout_set_text(layout, utfForm.c_str(), strlen(utfForm.c_str())); int i = 0; int clusterStart = 0; - ClusterIterator iti(layout, strlen(utfForm)); + ClusterIterator iti(layout, strlen(utfForm.c_str())); while (!iti.finished) { iti.Next(); int clusterEnd = iti.curIndex; - int places = g_utf8_strlen(utfForm + clusterStart, clusterEnd - clusterStart); + int places = g_utf8_strlen(utfForm.c_str() + clusterStart, clusterEnd - clusterStart); int place = 1; while (clusterStart < clusterEnd) { size_t lenChar = MultiByteLenFromIconv(convMeasure, s+i, len-i); @@ -1041,38 +1043,36 @@ void SurfaceImpl::MeasureWidths(Font &font_, const char *s, int len, XYPOSITION positions[i++] = iti.position - (places - place) * iti.distance / places; positionsCalculated++; } - clusterStart += UTF8CharLength(utfForm+clusterStart); + clusterStart += UTF8CharLength(utfForm.c_str()+clusterStart); place++; } } - delete []utfForm; PLATFORM_ASSERT(i == lenPositions); } } if (positionsCalculated < 1 ) { // Either Latin1 or DBCS conversion failed so treat as Latin1. SetConverter(PFont(font_)->characterSet); - char *utfForm = UTF8FromIconv(conv, s, len); - if (!utfForm) { + std::string utfForm = UTF8FromIconv(conv, s, len); + if (utfForm.empty()) { utfForm = UTF8FromLatin1(s, len); } - pango_layout_set_text(layout, utfForm, len); + pango_layout_set_text(layout, utfForm.c_str(), utfForm.length()); int i = 0; int clusterStart = 0; // Each Latin1 input character may take 1 or 2 bytes in UTF-8 // and groups of up to 3 may be represented as ligatures. - ClusterIterator iti(layout, strlen(utfForm)); + ClusterIterator iti(layout, utfForm.length()); while (!iti.finished) { iti.Next(); int clusterEnd = iti.curIndex; - int ligatureLength = g_utf8_strlen(utfForm + clusterStart, clusterEnd - clusterStart); + int ligatureLength = g_utf8_strlen(utfForm.c_str() + clusterStart, clusterEnd - clusterStart); PLATFORM_ASSERT(ligatureLength > 0 && ligatureLength <= 3); for (int charInLig=0; charInLig<ligatureLength; charInLig++) { positions[i++] = iti.position - (ligatureLength - 1 - charInLig) * iti.distance / ligatureLength; } clusterStart = clusterEnd; } - delete []utfForm; PLATFORM_ASSERT(i == lenPositions); } } @@ -1092,20 +1092,18 @@ void SurfaceImpl::MeasureWidths(Font &font_, const char *s, int len, XYPOSITION XYPOSITION SurfaceImpl::WidthText(Font &font_, const char *s, int len) { if (font_.GetID()) { if (PFont(font_)->pfd) { - char *utfForm = 0; + std::string utfForm; pango_layout_set_font_description(layout, PFont(font_)->pfd); PangoRectangle pos; if (et == UTF8) { pango_layout_set_text(layout, s, len); } else { - if (!utfForm) { // use iconv - SetConverter(PFont(font_)->characterSet); - utfForm = UTF8FromIconv(conv, s, len); - } - if (!utfForm) { // iconv failed so treat as Latin1 + SetConverter(PFont(font_)->characterSet); + utfForm = UTF8FromIconv(conv, s, len); + if (utfForm.empty()) { // iconv failed so treat as Latin1 utfForm = UTF8FromLatin1(s, len); } - pango_layout_set_text(layout, utfForm, len); + pango_layout_set_text(layout, utfForm.c_str(), utfForm.length()); } #ifdef PANGO_VERSION PangoLayoutLine *pangoLine = pango_layout_get_line_readonly(layout,0); @@ -1113,7 +1111,6 @@ XYPOSITION SurfaceImpl::WidthText(Font &font_, const char *s, int len) { PangoLayoutLine *pangoLine = pango_layout_get_line(layout,0); #endif pango_layout_line_get_extents(pangoLine, NULL, &pos); - delete []utfForm; return doubleFromPangoUnits(pos.width); } return 1; @@ -1883,30 +1880,26 @@ void ListBoxX::ClearRegisteredImages() { void ListBoxX::SetList(const char *listText, char separator, char typesep) { Clear(); int count = strlen(listText) + 1; - char *words = new char[count]; - if (words) { - memcpy(words, listText, count); - char *startword = words; - char *numword = NULL; - int i = 0; - for (; words[i]; i++) { - if (words[i] == separator) { - words[i] = '\0'; - if (numword) - *numword = '\0'; - Append(startword, numword?atoi(numword + 1):-1); - startword = words + i + 1; - numword = NULL; - } else if (words[i] == typesep) { - numword = words + i; - } - } - if (startword) { + std::vector<char> words(listText, listText+count); + char *startword = words.data(); + char *numword = NULL; + int i = 0; + for (; words[i]; i++) { + if (words[i] == separator) { + words[i] = '\0'; if (numword) *numword = '\0'; Append(startword, numword?atoi(numword + 1):-1); + startword = words.data() + i + 1; + numword = NULL; + } else if (words[i] == typesep) { + numword = words.data() + i; } - delete []words; + } + if (startword) { + if (numword) + *numword = '\0'; + Append(startword, numword?atoi(numword + 1):-1); } }

@@ -2165,5 +2158,6 @@ void Platform_Initialise() { }

void Platform_Finalise() { + FontCached::ReleaseAll(); FontMutexFree(); }

Modified: scintilla/gtk/ScintillaGTK.cxx 236 files changed, 84 insertions(+), 152 deletions(-) =================================================================== @@ -30,7 +30,6 @@ #ifdef SCI_LEXER #include "SciLexer.h" #endif -#include "SVector.h" #include "SplitVector.h" #include "Partitioning.h" #include "RunStyles.h" @@ -109,7 +108,7 @@ static GdkWindow *PWindow(const Window &w) { using namespace Scintilla; #endif

-extern char *UTF8FromLatin1(const char *s, int &len); +extern std::string UTF8FromLatin1(const char *s, int len);

class ScintillaGTK : public ScintillaBase { _ScintillaObject *sci; @@ -186,7 +185,6 @@ class ScintillaGTK : public ScintillaBase { virtual bool PaintContains(PRectangle rc); void FullPaint(); virtual PRectangle GetClientRectangle(); - void SyncPaint(PRectangle rc); virtual void ScrollText(int linesToMove); virtual void SetVerticalScrollPos(); virtual void SetHorizontalScrollPos(); @@ -280,7 +278,6 @@ class ScintillaGTK : public ScintillaBase { static void SelectionGet(GtkWidget *widget, GtkSelectionData *selection_data, guint info, guint time); static gint SelectionClear(GtkWidget *widget, GdkEventSelection *selection_event); - static void DragBegin(GtkWidget *widget, GdkDragContext *context); gboolean DragMotionThis(GdkDragContext *context, gint x, gint y, guint dragtime); static gboolean DragMotion(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint dragtime); @@ -373,12 +370,12 @@ static ScintillaGTK *ScintillaFromWidget(GtkWidget *widget) { #endif

#if PLAT_GTK_WIN32 - // There does not seem to be a real standard for indicating that the clipboard + // There does not seem to be a real standard for indicating that the clipboard // contains a rectangular selection, so copy Developer Studio. cfColumnSelect = static_cast<CLIPFORMAT>( ::RegisterClipboardFormat("MSDEVColumnSelect"));

- // Get intellimouse parameters when running on win32; otherwise use + // Get intellimouse parameters when running on win32; otherwise use // reasonable default #ifndef SPI_GETWHEELSCROLLLINES #define SPI_GETWHEELSCROLLLINES 104 @@ -837,37 +834,34 @@ void ScintillaGTK::StartDrag() { reinterpret_cast<GdkEvent *>(&evbtn)); }

-static char *ConvertText(int *lenResult, char *s, size_t len, const char *charSetDest, +static std::string ConvertText(char *s, size_t len, const char *charSetDest, const char *charSetSource, bool transliterations, bool silent=false) { // s is not const because of different versions of iconv disagreeing about const - *lenResult = 0; - char *destForm = 0; + std::string destForm; Converter conv(charSetDest, charSetSource, transliterations); if (conv) { - destForm = new char[len*3+1]; + size_t outLeft = len*3+1; + destForm = std::string(outLeft, '\0'); char *pin = s; size_t inLeft = len; - char *pout = destForm; - size_t outLeft = len*3+1; + char *putf = &destForm[0]; + char *pout = putf; size_t conversions = conv.Convert(&pin, &inLeft, &pout, &outLeft); if (conversions == ((size_t)(-1))) { - if (!silent) - fprintf(stderr, "iconv %s->%s failed for %s\n", - charSetSource, charSetDest, static_cast<char *>(s)); - delete []destForm; - destForm = 0; + if (!silent) { + if (len == 1) + fprintf(stderr, "iconv %s->%s failed for %0x '%s'\n", + charSetSource, charSetDest, (unsigned char)(*s), static_cast<char *>(s)); + else + fprintf(stderr, "iconv %s->%s failed for %s\n", + charSetSource, charSetDest, static_cast<char *>(s)); + } + destForm = std::string(); } else { -//fprintf(stderr, "iconv OK %s %d\n", destForm, pout - destForm); - *pout = '\0'; - *lenResult = pout - destForm; + destForm.resize(pout - putf); } } else { -fprintf(stderr, "Can not iconv %s %s\n", charSetDest, charSetSource); - } - if (!destForm) { - destForm = new char[1]; - destForm[0] = '\0'; - *lenResult = 0; + fprintf(stderr, "Can not iconv %s %s\n", charSetDest, charSetSource); } return destForm; } @@ -884,26 +878,18 @@ int ScintillaGTK::TargetAsUTF8(char *text) { // Need to convert const char *charSetBuffer = CharacterSetID(); if (*charSetBuffer) { -//~ fprintf(stderr, "AsUTF8 %s %d %0d-%0d\n", charSetBuffer, targetLength, targetStart, targetEnd); - char *s = new char[targetLength]; - if (s) { - pdoc->GetCharRange(s, targetStart, targetLength); -//~ fprintf(stderr, " "%s"\n", s); - if (text) { - char *tmputf = ConvertText(&targetLength, s, targetLength, "UTF-8", charSetBuffer, false); - memcpy(text, tmputf, targetLength); - delete []tmputf; -//~ fprintf(stderr, " "%s"\n", text); - } - delete []s; + std::string s = RangeText(targetStart, targetEnd); + std::string tmputf = ConvertText(&s[0], targetLength, "UTF-8", charSetBuffer, false); + if (text) { + memcpy(text, tmputf.c_str(), tmputf.length()); } + return tmputf.length(); } else { if (text) { pdoc->GetCharRange(text, targetStart, targetLength); } } } -//~ fprintf(stderr, "Length = %d bytes\n", targetLength); return targetLength; }

@@ -920,15 +906,11 @@ int ScintillaGTK::EncodedFromUTF8(char *utf8, char *encoded) { // Need to convert const char *charSetBuffer = CharacterSetID(); if (*charSetBuffer) { - int outLength = 0; - char *tmpEncoded = ConvertText(&outLength, utf8, inputLength, charSetBuffer, "UTF-8", true); - if (tmpEncoded) { - if (encoded) { - memcpy(encoded, tmpEncoded, outLength); - } - delete []tmpEncoded; + std::string tmpEncoded = ConvertText(utf8, inputLength, charSetBuffer, "UTF-8", true); + if (encoded) { + memcpy(encoded, tmpEncoded.c_str(), tmpEncoded.length()); } - return outLength; + return tmpEncoded.length(); } else { if (encoded) { memcpy(encoded, utf8, inputLength); @@ -966,7 +948,7 @@ sptr_t ScintillaGTK::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam

#ifdef SCI_LEXER case SCI_LOADLEXERLIBRARY: - LexerManager::GetInstance()->Load(reinterpret_cast<const char*>(lParam)); + LexerManager::GetInstance()->Load(reinterpret_cast<const char*>(lParam)); break; #endif case SCI_TARGETASUTF8: @@ -1109,30 +1091,6 @@ PRectangle ScintillaGTK::GetClientRectangle() { return rc; }

-// Synchronously paint a rectangle of the window. -void ScintillaGTK::SyncPaint(PRectangle rc) { - paintState = painting; - rcPaint = rc; - PRectangle rcClient = GetClientRectangle(); - paintingAllText = rcPaint.Contains(rcClient); - if (PWindow(wText)) { - Surface *sw = Surface::Allocate(SC_TECHNOLOGY_DEFAULT); - if (sw) { - cairo_t *cr = gdk_cairo_create(PWindow(wText)); - sw->Init(cr, PWidget(wText)); - Paint(sw, rc); - sw->Release(); - delete sw; - cairo_destroy(cr); - } - } - if (paintState == paintAbandoned) { - // Painting area was insufficient to cover new styling or brace highlight positions - FullPaint(); - } - paintState = notPainting; -} - void ScintillaGTK::ScrollText(int linesToMove) { int diff = vs.lineHeight * -linesToMove; //Platform::DebugPrintf("ScintillaGTK::ScrollText %d %d %0d,%0d %0d,%0d\n", linesToMove, diff, @@ -1301,11 +1259,10 @@ class CaseFolderDBCS : public CaseFolderTable { folded[0] = mapping[static_cast<unsigned char>(mixed[0])]; return 1; } else if (*charSet) { - int convertedLength = lenMixed; - char *sUTF8 = ConvertText(&convertedLength, const_cast<char *>(mixed), lenMixed, + std::string sUTF8 = ConvertText(const_cast<char *>(mixed), lenMixed, "UTF-8", charSet, false); - if (sUTF8) { - gchar *mapped = g_utf8_casefold(sUTF8, strlen(sUTF8)); + if (!sUTF8.empty()) { + gchar *mapped = g_utf8_casefold(sUTF8.c_str(), sUTF8.length()); size_t lenMapped = strlen(mapped); if (lenMapped < sizeFolded) { memcpy(folded, mapped, lenMapped); @@ -1314,7 +1271,6 @@ class CaseFolderDBCS : public CaseFolderTable { lenMapped = 1; } g_free(mapped); - delete []sUTF8; return lenMapped; } } @@ -1337,23 +1293,20 @@ CaseFolder *ScintillaGTK::CaseFolderForEncoding() { for (int i=0x80; i<0x100; i++) { char sCharacter[2] = "A"; sCharacter[0] = i; - int convertedLength = 1; - const char *sUTF8 = ConvertText(&convertedLength, sCharacter, 1, - "UTF-8", charSetBuffer, false); - if (sUTF8) { - gchar *mapped = g_utf8_casefold(sUTF8, strlen(sUTF8)); + // Silent as some bytes have no assigned character + std::string sUTF8 = ConvertText(sCharacter, 1, + "UTF-8", charSetBuffer, false, true); + if (!sUTF8.empty()) { + gchar *mapped = g_utf8_casefold(sUTF8.c_str(), sUTF8.length()); if (mapped) { - int mappedLength = strlen(mapped); - const char *mappedBack = ConvertText(&mappedLength, mapped, - mappedLength, charSetBuffer, "UTF-8", false, true); - if (mappedBack && (strlen(mappedBack) == 1) && (mappedBack[0] != sCharacter[0])) { + std::string mappedBack = ConvertText(mapped, strlen(mapped), + charSetBuffer, "UTF-8", false, true); + if ((mappedBack.length() == 1) && (mappedBack[0] != sCharacter[0])) { pcf->SetTranslation(sCharacter[0], mappedBack[0]); } - delete []mappedBack; g_free(mapped); } } - delete []sUTF8; } return pcf; } else { @@ -1364,6 +1317,24 @@ CaseFolder *ScintillaGTK::CaseFolderForEncoding() { } }

+namespace { + +struct CaseMapper { + gchar *mapped; // Must be freed with g_free + CaseMapper(const std::string &sUTF8, bool toUpperCase) { + if (toUpperCase) { + mapped = g_utf8_strup(sUTF8.c_str(), sUTF8.length()); + } else { + mapped = g_utf8_strdown(sUTF8.c_str(), sUTF8.length()); + } + } + ~CaseMapper() { + g_free(mapped); + } +}; + +} + std::string ScintillaGTK::CaseMapString(const std::string &s, int caseMapping) { if (s.size() == 0) return std::string(); @@ -1371,43 +1342,18 @@ CaseFolder *ScintillaGTK::CaseFolderForEncoding() { if (caseMapping == cmSame) return s;

- const char *needsFree1 = 0; // Must be freed with delete [] const char *charSetBuffer = CharacterSetID(); - const char *sUTF8 = s.c_str(); - int rangeBytes = s.size();

- int convertedLength = rangeBytes; - // Change text to UTF-8 - if (!IsUnicodeMode()) { - // Need to convert - if (*charSetBuffer) { - sUTF8 = ConvertText(&convertedLength, const_cast<char *>(s.c_str()), rangeBytes, - "UTF-8", charSetBuffer, false); - needsFree1 = sUTF8; - } - } - gchar *mapped; // Must be freed with g_free - if (caseMapping == cmUpper) { - mapped = g_utf8_strup(sUTF8, convertedLength); + if (IsUnicodeMode() || !*charSetBuffer) { + CaseMapper mapper(s, caseMapping == cmUpper); + return std::string(mapper.mapped, strlen(mapper.mapped)); } else { - mapped = g_utf8_strdown(sUTF8, convertedLength); - } - int mappedLength = strlen(mapped); - char *mappedBack = mapped; - - char *needsFree2 = 0; // Must be freed with delete [] - if (!IsUnicodeMode()) { - if (*charSetBuffer) { - mappedBack = ConvertText(&mappedLength, mapped, mappedLength, charSetBuffer, "UTF-8", false); - needsFree2 = mappedBack; - } + // Change text to UTF-8 + std::string sUTF8 = ConvertText(const_cast<char *>(s.c_str()), s.length(), + "UTF-8", charSetBuffer, false); + CaseMapper mapper(sUTF8, caseMapping == cmUpper); + return ConvertText(mapper.mapped, strlen(mapper.mapped), charSetBuffer, "UTF-8", false); } - - std::string ret(mappedBack, mappedLength); - g_free(mapped); - delete []needsFree1; - delete []needsFree2; - return ret; }

int ScintillaGTK::KeyDefault(int key, int modifiers) { @@ -1528,9 +1474,7 @@ void ScintillaGTK::GetGtkSelectionText(GtkSelectionData *selectionData, Selectio

// Return empty string if selection is not a string if ((selectionTypeData != GDK_TARGET_STRING) && (selectionTypeData != atomUTF8)) { - char *empty = new char[1]; - empty[0] = '\0'; - selText.Set(empty, 0, SC_CP_UTF8, 0, false, false); + selText.Copy("", 0, SC_CP_UTF8, 0, false, false); return; }

@@ -1544,28 +1488,24 @@ void ScintillaGTK::GetGtkSelectionText(GtkSelectionData *selectionData, Selectio len--; // Forget the extra '\0' #endif

- char *dest; + std::string dest = Document::TransformLineEnds(data, len, pdoc->eolMode); if (selectionTypeData == GDK_TARGET_STRING) { - dest = Document::TransformLineEnds(&len, data, len, pdoc->eolMode); if (IsUnicodeMode()) { // Unknown encoding so assume in Latin1 - char *destPrevious = dest; - dest = UTF8FromLatin1(dest, len); - selText.Set(dest, len, SC_CP_UTF8, 0, selText.rectangular, false); - delete []destPrevious; + dest = UTF8FromLatin1(dest.c_str(), len); + selText.Copy(dest.c_str(), dest.length(), SC_CP_UTF8, 0, selText.rectangular, false); } else { // Assume buffer is in same encoding as selection - selText.Set(dest, len, pdoc->dbcsCodePage, + selText.Copy(dest.c_str(), dest.length(), pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, isRectangular, false); } } else { // UTF-8 - dest = Document::TransformLineEnds(&len, data, len, pdoc->eolMode); - selText.Set(dest, len, SC_CP_UTF8, 0, isRectangular, false); + selText.Copy(dest.c_str(), dest.length(), SC_CP_UTF8, 0, isRectangular, false); const char *charSetBuffer = CharacterSetID(); if (!IsUnicodeMode() && *charSetBuffer) { // Convert to locale - dest = ConvertText(&len, selText.s, selText.len, charSetBuffer, "UTF-8", true); - selText.Set(dest, len, pdoc->dbcsCodePage, + dest = ConvertText(selText.s, selText.len, charSetBuffer, "UTF-8", true); + selText.Copy(dest.c_str(), dest.length(), pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, selText.rectangular, false); } } @@ -1611,11 +1551,10 @@ void ScintillaGTK::ReceivedSelection(GtkSelectionData *selection_data) { void ScintillaGTK::ReceivedDrop(GtkSelectionData *selection_data) { dragWasDropped = true; if (TypeOfGSD(selection_data) == atomUriList || TypeOfGSD(selection_data) == atomDROPFILES_DND) { - char *ptr = new char[LengthOfGSD(selection_data) + 1]; - ptr[LengthOfGSD(selection_data)] = '\0'; - memcpy(ptr, DataOfGSD(selection_data), LengthOfGSD(selection_data)); - NotifyURIDropped(ptr); - delete []ptr; + const char *data = reinterpret_cast<const char *>(DataOfGSD(selection_data)); + std::vector<char> drop(data, data + LengthOfGSD(selection_data)); + drop.push_back('\0'); + NotifyURIDropped(drop.data()); } else if ((TypeOfGSD(selection_data) == GDK_TARGET_STRING) || (TypeOfGSD(selection_data) == atomUTF8)) { if (TypeOfGSD(selection_data) > 0) { SelectionText selText; @@ -1637,10 +1576,9 @@ void ScintillaGTK::GetSelection(GtkSelectionData *selection_data, guint info, Se // from code below SelectionText *newline_normalized = NULL; { - int tmpstr_len; - char *tmpstr = Document::TransformLineEnds(&tmpstr_len, text->s, text->len, SC_EOL_LF); + std::string tmpstr = Document::TransformLineEnds(text->s, text->len, SC_EOL_LF); newline_normalized = new SelectionText(); - newline_normalized->Set(tmpstr, tmpstr_len, SC_CP_UTF8, 0, text->rectangular, false); + newline_normalized->Copy(tmpstr.c_str(), tmpstr.length(), SC_CP_UTF8, 0, text->rectangular, false); text = newline_normalized; } #endif @@ -1650,10 +1588,9 @@ void ScintillaGTK::GetSelection(GtkSelectionData *selection_data, guint info, Se if ((text->codePage != SC_CP_UTF8) && (info == TARGET_UTF8_STRING)) { const char *charSet = ::CharacterSetID(text->characterSet); if (*charSet) { - int new_len; - char* tmputf = ConvertText(&new_len, text->s, text->len, "UTF-8", charSet, false); + std::string tmputf = ConvertText(text->s, text->len, "UTF-8", charSet, false); converted = new SelectionText(); - converted->Set(tmputf, new_len, SC_CP_UTF8, 0, text->rectangular, false); + converted->Copy(tmputf.c_str(), tmputf.length(), SC_CP_UTF8, 0, text->rectangular, false); text = converted; } } @@ -1923,8 +1860,7 @@ gint ScintillaGTK::MouseRelease(GtkWidget *widget, GdkEventButton *event) {

// win32gtk and GTK >= 2 use SCROLL_* events instead of passing the // button4/5/6/7 events to the GTK app -gint ScintillaGTK::ScrollEvent(GtkWidget *widget, - GdkEventScroll *event) { +gint ScintillaGTK::ScrollEvent(GtkWidget *widget, GdkEventScroll *event) { ScintillaGTK *sciThis = ScintillaFromWidget(widget); try {

@@ -2617,10 +2553,6 @@ gint ScintillaGTK::SelectionClear(GtkWidget *widget, GdkEventSelection *selectio return TRUE; }

-void ScintillaGTK::DragBegin(GtkWidget *, GdkDragContext *) { - //Platform::DebugPrintf("DragBegin\n"); -} - gboolean ScintillaGTK::DragMotionThis(GdkDragContext *context, gint x, gint y, guint dragtime) { try {

Modified: scintilla/include/SciLexer.h 9 files changed, 9 insertions(+), 0 deletions(-) =================================================================== @@ -120,6 +120,7 @@ #define SCLEX_ECL 105 #define SCLEX_OSCRIPT 106 #define SCLEX_VISUALPROLOG 107 +#define SCLEX_LITERATEHASKELL 108 #define SCLEX_AUTOMATIC 1000 #define SCE_P_DEFAULT 0 #define SCE_P_COMMENTLINE 1 @@ -161,6 +162,7 @@ #define SCE_C_TRIPLEVERBATIM 21 #define SCE_C_HASHQUOTEDSTRING 22 #define SCE_C_PREPROCESSORCOMMENT 23 +#define SCE_C_PREPROCESSORCOMMENTDOC 24 #define SCE_D_DEFAULT 0 #define SCE_D_COMMENT 1 #define SCE_D_COMMENTLINE 2 @@ -1022,6 +1024,10 @@ #define SCE_HA_COMMENTBLOCK3 16 #define SCE_HA_PRAGMA 17 #define SCE_HA_PREPROCESSOR 18 +#define SCE_HA_STRINGEOL 19 +#define SCE_HA_RESERVED_OPERATOR 20 +#define SCE_HA_LITERATE_COMMENT 21 +#define SCE_HA_LITERATE_CODEDELIM 22 #define SCE_T3_DEFAULT 0 #define SCE_T3_X_DEFAULT 1 #define SCE_T3_PREPROCESSOR 2 @@ -1326,6 +1332,9 @@ #define SCE_POWERSHELL_FUNCTION 11 #define SCE_POWERSHELL_USER1 12 #define SCE_POWERSHELL_COMMENTSTREAM 13 +#define SCE_POWERSHELL_HERE_STRING 14 +#define SCE_POWERSHELL_HERE_CHARACTER 15 +#define SCE_POWERSHELL_COMMENTDOCKEYWORD 16 #define SCE_MYSQL_DEFAULT 0 #define SCE_MYSQL_COMMENT 1 #define SCE_MYSQL_COMMENTLINE 2

Modified: scintilla/include/Scintilla.h 13 files changed, 13 insertions(+), 0 deletions(-) =================================================================== @@ -264,6 +264,7 @@ #define INDIC_SQUIGGLELOW 11 #define INDIC_DOTBOX 12 #define INDIC_SQUIGGLEPIXMAP 13 +#define INDIC_COMPOSITIONTHICK 14 #define INDIC_MAX 31 #define INDIC_CONTAINER 8 #define INDIC0_MASK 0x20 @@ -440,7 +441,19 @@ #define SCI_SETFOLDEXPANDED 2229 #define SCI_GETFOLDEXPANDED 2230 #define SCI_TOGGLEFOLD 2231 +#define SC_FOLDACTION_CONTRACT 0 +#define SC_FOLDACTION_EXPAND 1 +#define SC_FOLDACTION_TOGGLE 2 +#define SCI_FOLDLINE 2237 +#define SCI_FOLDCHILDREN 2238 +#define SCI_EXPANDCHILDREN 2239 +#define SCI_FOLDALL 2662 #define SCI_ENSUREVISIBLE 2232 +#define SC_AUTOMATICFOLD_SHOW 0x0001 +#define SC_AUTOMATICFOLD_CLICK 0x0002 +#define SC_AUTOMATICFOLD_CHANGE 0x0004 +#define SCI_SETAUTOMATICFOLD 2663 +#define SCI_GETAUTOMATICFOLD 2664 #define SC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002 #define SC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004 #define SC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008

Modified: scintilla/include/Scintilla.iface 38 files changed, 38 insertions(+), 0 deletions(-) =================================================================== @@ -581,6 +581,7 @@ val INDIC_DOTS=10 val INDIC_SQUIGGLELOW=11 val INDIC_DOTBOX=12 val INDIC_SQUIGGLEPIXMAP=13 +val INDIC_COMPOSITIONTHICK=14 val INDIC_MAX=31 val INDIC_CONTAINER=8 val INDIC0_MASK=0x20 @@ -1109,9 +1110,37 @@ get bool GetFoldExpanded=2230(int line,) # Switch a header line between expanded and contracted. fun void ToggleFold=2231(int line,)

+enu FoldAction=SC_FOLDACTION +val SC_FOLDACTION_CONTRACT=0 +val SC_FOLDACTION_EXPAND=1 +val SC_FOLDACTION_TOGGLE=2 + +# Expand or contract a fold header. +fun void FoldLine=2237(int line, int action) + +# Expand or contract a fold header and its children. +fun void FoldChildren=2238(int line, int action) + +# Expand a fold header and all children. Use the level argument instead of the line's current level. +fun void ExpandChildren=2239(int line, int level) + +# Expand or contract all fold headers. +fun void FoldAll=2662(int action,) + # Ensure a particular line is visible by expanding any header line hiding it. fun void EnsureVisible=2232(int line,)

+enu AutomaticFold=SC_AUTOMATICFOLD_ +val SC_AUTOMATICFOLD_SHOW=0x0001 +val SC_AUTOMATICFOLD_CLICK=0x0002 +val SC_AUTOMATICFOLD_CHANGE=0x0004 + +# Set automatic folding behaviours. +set void SetAutomaticFold=2663(int automaticFold,) + +# Get automatic folding behaviours. +get int GetAutomaticFold=2664(,) + enu FoldFlag=SC_FOLDFLAG_ val SC_FOLDFLAG_LINEBEFORE_EXPANDED=0x0002 val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004 @@ -2549,6 +2578,7 @@ val SCLEX_AVS=104 val SCLEX_ECL=105 val SCLEX_OSCRIPT=106 val SCLEX_VISUALPROLOG=107 +val SCLEX_LITERATEHASKELL=108

# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a # value assigned in sequence from SCLEX_AUTOMATIC+1. @@ -2599,6 +2629,7 @@ val SCE_C_STRINGRAW=20 val SCE_C_TRIPLEVERBATIM=21 val SCE_C_HASHQUOTEDSTRING=22 val SCE_C_PREPROCESSORCOMMENT=23 +val SCE_C_PREPROCESSORCOMMENTDOC=24 # Lexical states for SCLEX_D lex D=SCLEX_D SCE_D_ val SCE_D_DEFAULT=0 @@ -3583,6 +3614,10 @@ val SCE_HA_COMMENTBLOCK2=15 val SCE_HA_COMMENTBLOCK3=16 val SCE_HA_PRAGMA=17 val SCE_HA_PREPROCESSOR=18 +val SCE_HA_STRINGEOL=19 +val SCE_HA_RESERVED_OPERATOR=20 +val SCE_HA_LITERATE_COMMENT=21 +val SCE_HA_LITERATE_CODEDELIM=22 # Lexical states of SCLEX_TADS3 lex TADS3=SCLEX_TADS3 SCE_T3_ val SCE_T3_DEFAULT=0 @@ -3923,6 +3958,9 @@ val SCE_POWERSHELL_ALIAS=10 val SCE_POWERSHELL_FUNCTION=11 val SCE_POWERSHELL_USER1=12 val SCE_POWERSHELL_COMMENTSTREAM=13 +val SCE_POWERSHELL_HERE_STRING=14 +val SCE_POWERSHELL_HERE_CHARACTER=15 +val SCE_POWERSHELL_COMMENTDOCKEYWORD=16 # Lexical state for SCLEX_MYSQL lex MySQL=SCLEX_MYSQL SCE_MYSQL_ val SCE_MYSQL_DEFAULT=0

Modified: scintilla/lexers/LexCPP.cxx 15 files changed, 10 insertions(+), 5 deletions(-) =================================================================== @@ -455,9 +455,9 @@ int SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) { if (n == 4) { // Rebuild preprocessorDefinitions preprocessorDefinitionsStart.clear(); - for (int nDefinition = 0; nDefinition < ppDefinitions.len; nDefinition++) { - char *cpDefinition = ppDefinitions.words[nDefinition]; - char *cpEquals = strchr(cpDefinition, '='); + for (int nDefinition = 0; nDefinition < ppDefinitions.Length(); nDefinition++) { + const char *cpDefinition = ppDefinitions.WordAt(nDefinition); + const char *cpEquals = strchr(cpDefinition, '='); if (cpEquals) { std::string name(cpDefinition, cpEquals - cpDefinition); std::string val(cpEquals+1); @@ -672,7 +672,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, sc.SetState(SCE_C_DEFAULT|activitySet); } break; - case SCE_C_PREPROCESSOR: + case SCE_C_PREPROCESSOR: if (options.stylingWithinPreprocessor) { if (IsASpace(sc.ch)) { sc.SetState(SCE_C_DEFAULT|activitySet); @@ -683,7 +683,11 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, if ((isIncludePreprocessor && sc.Match('<')) || sc.Match('"')) { isStringInPreprocessor = true; } else if (sc.Match('/', '*')) { - sc.SetState(SCE_C_PREPROCESSORCOMMENT|activitySet); + if (sc.Match("/**") || sc.Match("/*!")) { + sc.SetState(SCE_C_PREPROCESSORCOMMENTDOC|activitySet); + } else { + sc.SetState(SCE_C_PREPROCESSORCOMMENT|activitySet); + } sc.Forward(); // Eat the * } else if (sc.Match('/', '/')) { sc.SetState(SCE_C_DEFAULT|activitySet); @@ -691,6 +695,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, } break; case SCE_C_PREPROCESSORCOMMENT: + case SCE_C_PREPROCESSORCOMMENTDOC: if (sc.Match('*', '/')) { sc.Forward(); sc.ForwardSetState(SCE_C_PREPROCESSOR|activitySet);

Modified: scintilla/lexers/LexHaskell.cxx 1063 files changed, 871 insertions(+), 192 deletions(-) =================================================================== @@ -4,21 +4,20 @@ * A haskell lexer for the scintilla code control. * Some stuff "lended" from LexPython.cxx and LexCPP.cxx. * External lexer stuff inspired from the caml external lexer. + * Folder copied from Python's. * * Written by Tobias Engvall - tumm at dtek dot chalmers dot se * * Several bug fixes by Krasimir Angelov - kr.angelov at gmail.com * - * Improvements by kudah - kudahkukarek at gmail.com + * Improved by kudah kudahkukarek@gmail.com * * TODO: - * * Implement a folder :) - * * Nice Character-lexing (stuff inside '''), LexPython has - * this. - * + * * A proper lexical folder to fold group declarations, comments, pragmas, + * #ifdefs, explicit layout, lists, tuples, quasi-quotes, splces, etc, etc, + * etc. * *****************************************************************/ - #include <stdlib.h> #include <string.h> #include <stdio.h> @@ -26,6 +25,9 @@ #include <assert.h> #include <ctype.h>

+#include <string> +#include <map> + #include "ILexer.h" #include "Scintilla.h" #include "SciLexer.h" @@ -37,195 +39,746 @@ #include "StyleContext.h" #include "CharacterSet.h" #include "LexerModule.h" +#include "OptionSet.h"

#ifdef SCI_NAMESPACE using namespace Scintilla; #endif

-#ifdef BUILD_AS_EXTERNAL_LEXER +static int u_iswalpha(int); +static int u_iswalnum(int); +static int u_iswupper(int); +static int u_IsHaskellSymbol(int);

-#include "ExternalLexer.h" -#include "WindowAccessor.h" +// #define HASKELL_UNICODE

-#define BUILD_EXTERNAL_LEXER 0 +#ifndef HASKELL_UNICODE + +// Stubs + +static int u_iswalpha(int) { + return 0; +} + +static int u_iswalnum(int) { + return 0; +} + +static int u_iswupper(int) { + return 0; +} + +static int u_IsHaskellSymbol(int) { + return 0; +}

#endif

-#define HA_MODE_DEFAULT 0 -#define HA_MODE_IMPORT1 1 -#define HA_MODE_IMPORT2 2 -#define HA_MODE_IMPORT3 3 -#define HA_MODE_MODULE 4 -#define HA_MODE_FFI 5 -#define HA_MODE_TYPE 6 +static inline bool IsHaskellLetter(const int ch) { + if (IsASCII(ch)) { + return (ch >= 'a' && ch <= 'z') + || (ch >= 'A' && ch <= 'Z'); + } else { + return u_iswalpha(ch) != 0; + } +} + +static inline bool IsHaskellAlphaNumeric(const int ch) { + if (IsASCII(ch)) { + return IsAlphaNumeric(ch); + } else { + return u_iswalnum(ch) != 0; + } +} + +static inline bool IsHaskellUpperCase(const int ch) { + if (IsASCII(ch)) { + return ch >= 'A' && ch <= 'Z'; + } else { + return u_iswupper(ch) != 0; + } +}

-static inline bool IsAWordStart(const int ch) { - return (IsLowerCase(ch) || IsUpperCase(ch) || ch == '_'); +static inline bool IsAnHaskellOperatorChar(const int ch) { + if (IsASCII(ch)) { + return + ( ch == '!' || ch == '#' || ch == '$' || ch == '%' + || ch == '&' || ch == '*' || ch == '+' || ch == '-' + || ch == '.' || ch == '/' || ch == ':' || ch == '<' + || ch == '=' || ch == '>' || ch == '?' || ch == '@' + || ch == '^' || ch == '|' || ch == '~' || ch == '\'); + } else { + return u_IsHaskellSymbol(ch) != 0; + } }

-static inline bool IsAWordChar(const int ch, const bool magicHash) { - return ( IsAlphaNumeric(ch) +static inline bool IsAHaskellWordStart(const int ch) { + return IsHaskellLetter(ch) || ch == '_'; +} + +static inline bool IsAHaskellWordChar(const int ch) { + return ( IsHaskellAlphaNumeric(ch) || ch == '_' - || ch == ''' - || (magicHash && ch == '#')); + || ch == '''); }

-static inline bool IsAnOperatorChar(const int ch) { - return - ( ch == '!' || ch == '#' || ch == '$' || ch == '%' - || ch == '&' || ch == '*' || ch == '+' || ch == '-' - || ch == '.' || ch == '/' || ch == ':' || ch == '<' - || ch == '=' || ch == '>' || ch == '?' || ch == '@' - || ch == '\' || ch == '^' || ch == '|' || ch == '~'); +static inline bool IsCommentBlockStyle(int style) { + return (style >= SCE_HA_COMMENTBLOCK && style <= SCE_HA_COMMENTBLOCK3); }

-static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle, - WordList *keywordlists[], Accessor &styler) { +static inline bool IsCommentStyle(int style) { + return (style >= SCE_HA_COMMENTLINE && style <= SCE_HA_COMMENTBLOCK3) + || ( style == SCE_HA_LITERATE_COMMENT + || style == SCE_HA_LITERATE_CODEDELIM); +}

- WordList &keywords = *keywordlists[0]; - WordList &ffi = *keywordlists[1]; +// styles which do not belong to Haskell, but to external tools +static inline bool IsExternalStyle(int style) { + return ( style == SCE_HA_PREPROCESSOR + || style == SCE_HA_LITERATE_COMMENT + || style == SCE_HA_LITERATE_CODEDELIM); +}

- // property lexer.haskell.allow.hash - // Set to 1 to allow the # character in identifiers with the haskell lexer. - // (GHC -XMagicHash extension) - const bool magicHash = styler.GetPropertyInt("lexer.haskell.allow.hash") != 0; - const bool stylingWithinPreprocessor = styler.GetPropertyInt("styling.within.preprocessor") != 0; +static inline int CommentBlockStyleFromNestLevel(const unsigned int nestLevel) { + return SCE_HA_COMMENTBLOCK + (nestLevel % 3); +}

- StyleContext sc(startPos, length, initStyle, styler); +// Mangled version of lexlib/Accessor.cxx IndentAmount. +// Modified to treat comment blocks as whitespace +// plus special case for commentline/preprocessor. +static int HaskellIndentAmount(Accessor &styler, const int line) { + + // Determines the indentation level of the current line + // Comment blocks are treated as whitespace + + int pos = styler.LineStart(line); + int eol_pos = styler.LineStart(line + 1) - 1; + + char ch = styler[pos]; + int style = styler.StyleAt(pos); + + int indent = 0; + bool inPrevPrefix = line > 0; + + int posPrev = inPrevPrefix ? styler.LineStart(line-1) : 0; + + while (( ch == ' ' || ch == '\t' + || IsCommentBlockStyle(style) + || style == SCE_HA_LITERATE_CODEDELIM) + && (pos < eol_pos)) { + if (inPrevPrefix) { + char chPrev = styler[posPrev++]; + if (chPrev != ' ' && chPrev != '\t') { + inPrevPrefix = false; + } + } + if (ch == '\t') { + indent = (indent / 8 + 1) * 8; + } else { // Space or comment block + indent++; + } + pos++; + ch = styler[pos]; + style = styler.StyleAt(pos); + } + + indent += SC_FOLDLEVELBASE; + // if completely empty line or the start of a comment or preprocessor... + if ( styler.LineStart(line) == styler.Length() + || ch == ' ' + || ch == '\t' + || ch == '\n' + || ch == '\r' + || IsCommentStyle(style) + || style == SCE_HA_PREPROCESSOR) + return indent | SC_FOLDLEVELWHITEFLAG; + else + return indent; +} + +struct OptionsHaskell { + bool magicHash; + bool allowQuotes; + bool implicitParams; + bool highlightSafe; + bool cpp; + bool stylingWithinPreprocessor; + bool fold; + bool foldComment; + bool foldCompact; + bool foldImports; + OptionsHaskell() { + magicHash = true; // Widespread use, enabled by default. + allowQuotes = true; // Widespread use, enabled by default. + implicitParams = false; // Fell out of favor, seldom used, disabled. + highlightSafe = true; // Moderately used, doesn't hurt to enable. + cpp = true; // Widespread use, enabled by default; + stylingWithinPreprocessor = false; + fold = false; + foldComment = false; + foldCompact = false; + foldImports = false; + } +}; + +static const char * const haskellWordListDesc[] = { + "Keywords", + "FFI", + "Reserved operators", + 0 +}; + +struct OptionSetHaskell : public OptionSet<OptionsHaskell> { + OptionSetHaskell() { + DefineProperty("lexer.haskell.allow.hash", &OptionsHaskell::magicHash, + "Set to 0 to disallow the '#' character at the end of identifiers and " + "literals with the haskell lexer " + "(GHC -XMagicHash extension)"); + + DefineProperty("lexer.haskell.allow.quotes", &OptionsHaskell::allowQuotes, + "Set to 0 to disable highlighting of Template Haskell name quotations " + "and promoted constructors " + "(GHC -XTemplateHaskell and -XDataKinds extensions)"); + + DefineProperty("lexer.haskell.allow.questionmark", &OptionsHaskell::implicitParams, + "Set to 1 to allow the '?' character at the start of identifiers " + "with the haskell lexer " + "(GHC & Hugs -XImplicitParams extension)"); + + DefineProperty("lexer.haskell.import.safe", &OptionsHaskell::highlightSafe, + "Set to 0 to disallow "safe" keyword in imports " + "(GHC -XSafe, -XTrustworthy, -XUnsafe extensions)"); + + DefineProperty("lexer.haskell.cpp", &OptionsHaskell::cpp, + "Set to 0 to disable C-preprocessor highlighting " + "(-XCPP extension)"); + + DefineProperty("styling.within.preprocessor", &OptionsHaskell::stylingWithinPreprocessor, + "For Haskell code, determines whether all preprocessor code is styled in the " + "preprocessor style (0, the default) or only from the initial # to the end " + "of the command word(1)." + ); + + DefineProperty("fold", &OptionsHaskell::fold); + + DefineProperty("fold.comment", &OptionsHaskell::foldComment); + + DefineProperty("fold.compact", &OptionsHaskell::foldCompact); + + DefineProperty("fold.haskell.imports", &OptionsHaskell::foldImports, + "Set to 1 to enable folding of import declarations"); + + DefineWordListSets(haskellWordListDesc); + } +}; + +class LexerHaskell : public ILexer { + bool literate; + int firstImportLine; + int firstImportIndent; + WordList keywords; + WordList ffi; + WordList reserved_operators; + OptionsHaskell options; + OptionSetHaskell osHaskell; + + enum HashCount { + oneHash + ,twoHashes + ,unlimitedHashes + }; + + enum KeywordMode { + HA_MODE_DEFAULT = 0 + ,HA_MODE_IMPORT1 = 1 // after "import", before "qualified" or "safe" or package name or module name. + ,HA_MODE_IMPORT2 = 2 // after module name, before "as" or "hiding". + ,HA_MODE_IMPORT3 = 3 // after "as", before "hiding" + ,HA_MODE_MODULE = 4 // after "module", before module name. + ,HA_MODE_FFI = 5 // after "foreign", before FFI keywords + ,HA_MODE_TYPE = 6 // after "type" or "data", before "family" + }; + + enum LiterateMode { + LITERATE_BIRD = 0 // if '>' is the first character on the line, + // color '>' as a codedelim and the rest of + // the line as code. + // else if "\begin{code}" is the only word on the + // line except whitespace, switch to LITERATE_BLOCK + // otherwise color the line as a literate comment. + ,LITERATE_BLOCK = 1 // if the string "\end{code}" is encountered at column + // 0 ignoring all later characters, color the line + // as a codedelim and switch to LITERATE_BIRD + // otherwise color the line as code. + }; + + struct HaskellLineInfo { + unsigned int nestLevel; // 22 bits ought to be enough for anybody + unsigned int nonexternalStyle; // 5 bits, widen if number of styles goes + // beyond 31. + bool pragma; + LiterateMode lmode; + KeywordMode mode; + + HaskellLineInfo(int state) : + nestLevel (state >> 10) + , nonexternalStyle ((state >> 5) & 0x1F) + , pragma ((state >> 4) & 0x1) + , lmode (static_cast<LiterateMode>((state >> 3) & 0x1)) + , mode (static_cast<KeywordMode>(state & 0x7)) + {} + + int ToLineState() { + return + (nestLevel << 10) + | (nonexternalStyle << 5) + | (pragma << 4) + | (lmode << 3) + | mode; + } + }; + + inline void skipMagicHash(StyleContext &sc, const HashCount hashes) const { + if (options.magicHash && sc.ch == '#') { + sc.Forward(); + if (hashes == twoHashes && sc.ch == '#') { + sc.Forward(); + } else if (hashes == unlimitedHashes) { + while (sc.ch == '#') { + sc.Forward(); + } + } + } + } + + bool LineContainsImport(const int line, Accessor &styler) const { + if (options.foldImports) { + int currentPos = styler.LineStart(line); + int style = styler.StyleAt(currentPos); + + int eol_pos = styler.LineStart(line + 1) - 1; + + while (currentPos < eol_pos) { + int ch = styler[currentPos]; + style = styler.StyleAt(currentPos); + + if (ch == ' ' || ch == '\t' + || IsCommentBlockStyle(style) + || style == SCE_HA_LITERATE_CODEDELIM) { + currentPos++; + } else { + break; + } + } + + return (style == SCE_HA_KEYWORD + && styler.Match(currentPos, "import")); + } else { + return false; + } + } + + inline int IndentAmountWithOffset(Accessor &styler, const int line) const { + const int indent = HaskellIndentAmount(styler, line); + const int indentLevel = indent & SC_FOLDLEVELNUMBERMASK; + return indentLevel <= ((firstImportIndent - 1) + SC_FOLDLEVELBASE) + ? indent + : (indentLevel + firstImportIndent) | (indent & ~SC_FOLDLEVELNUMBERMASK); + } + + inline int IndentLevelRemoveIndentOffset(const int indentLevel) const { + return indentLevel <= ((firstImportIndent - 1) + SC_FOLDLEVELBASE) + ? indentLevel + : indentLevel - firstImportIndent; + } + +public: + LexerHaskell(bool literate_) + : literate(literate_) + , firstImportLine(-1) + , firstImportIndent(0) + {} + virtual ~LexerHaskell() {} + + void SCI_METHOD Release() { + delete this; + } + + int SCI_METHOD Version() const { + return lvOriginal; + } + + const char * SCI_METHOD PropertyNames() { + return osHaskell.PropertyNames(); + } + + int SCI_METHOD PropertyType(const char *name) { + return osHaskell.PropertyType(name); + } + + const char * SCI_METHOD DescribeProperty(const char *name) { + return osHaskell.DescribeProperty(name); + } + + int SCI_METHOD PropertySet(const char *key, const char *val); + + const char * SCI_METHOD DescribeWordListSets() { + return osHaskell.DescribeWordListSets(); + } + + int SCI_METHOD WordListSet(int n, const char *wl); + + void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess); + + void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess); + + void * SCI_METHOD PrivateCall(int, void *) { + return 0; + } + + static ILexer *LexerFactoryHaskell() { + return new LexerHaskell(false); + } + + static ILexer *LexerFactoryLiterateHaskell() { + return new LexerHaskell(true); + } +}; + +int SCI_METHOD LexerHaskell::PropertySet(const char *key, const char *val) { + if (osHaskell.PropertySet(&options, key, val)) { + return 0; + } + return -1; +} + +int SCI_METHOD LexerHaskell::WordListSet(int n, const char *wl) { + WordList *wordListN = 0; + switch (n) { + case 0: + wordListN = &keywords; + break; + case 1: + wordListN = &ffi; + break; + case 2: + wordListN = &reserved_operators; + break; + } + int firstModification = -1; + if (wordListN) { + WordList wlNew; + wlNew.Set(wl); + if (*wordListN != wlNew) { + wordListN->Set(wl); + firstModification = 0; + } + } + return firstModification; +} + +void SCI_METHOD LexerHaskell::Lex(unsigned int startPos, int length, int initStyle + ,IDocument *pAccess) { + LexAccessor styler(pAccess);

int lineCurrent = styler.GetLine(startPos); - int state = lineCurrent ? styler.GetLineState(lineCurrent-1) - : HA_MODE_DEFAULT; - int mode = state & 0xF; - int xmode = state >> 4; // obscure parameter. Means different things in different modes. + + HaskellLineInfo hs = HaskellLineInfo(lineCurrent ? styler.GetLineState(lineCurrent-1) : 0); + + // Do not leak onto next line + if (initStyle == SCE_HA_STRINGEOL) + initStyle = SCE_HA_DEFAULT; + else if (initStyle == SCE_HA_LITERATE_CODEDELIM) + initStyle = hs.nonexternalStyle; + + StyleContext sc(startPos, length, initStyle, styler); + + int base = 10; + bool dot = false; + + bool inDashes = false; + bool alreadyInTheMiddleOfOperator = false; + + assert(!(IsCommentBlockStyle(initStyle) && hs.nestLevel == 0));

while (sc.More()) { // Check for state end

+ if (!IsExternalStyle(sc.state)) { + hs.nonexternalStyle = sc.state; + } + + // For lexer to work, states should unconditionally forward at least one + // character. + // If they don't, they should still check if they are at line end and + // forward if so. + // If a state forwards more than one character, it should check every time + // that it is not a line end and cease forwarding otherwise. + if (sc.atLineEnd) { + // Remember the line state for future incremental lexing + styler.SetLineState(lineCurrent, hs.ToLineState()); + lineCurrent++; + } + + // Handle line continuation generically. + if (sc.ch == '\' && (sc.chNext == '\n' || sc.chNext == '\r') + && ( sc.state == SCE_HA_STRING + || sc.state == SCE_HA_PREPROCESSOR)) { + // Remember the line state for future incremental lexing + styler.SetLineState(lineCurrent, hs.ToLineState()); + lineCurrent++; + + sc.Forward(); + if (sc.ch == '\r' && sc.chNext == '\n') { + sc.Forward(); + } + sc.Forward(); + + continue; + } + + if (sc.atLineStart) { + + if (sc.state == SCE_HA_STRING || sc.state == SCE_HA_CHARACTER) { + // Prevent SCE_HA_STRINGEOL from leaking back to previous line + sc.SetState(sc.state); + } + + if (literate && hs.lmode == LITERATE_BIRD) { + if (!IsExternalStyle(sc.state)) { + sc.SetState(SCE_HA_LITERATE_COMMENT); + } + } + } + + // External + // Literate + if ( literate && hs.lmode == LITERATE_BIRD && sc.atLineStart + && sc.ch == '>') { + sc.SetState(SCE_HA_LITERATE_CODEDELIM); + sc.ForwardSetState(hs.nonexternalStyle); + } + else if (literate && hs.lmode == LITERATE_BIRD && sc.atLineStart + && ( sc.ch == ' ' || sc.ch == '\t' + || sc.Match("\begin{code}"))) { + sc.SetState(sc.state); + + while ((sc.ch == ' ' || sc.ch == '\t') && sc.More()) + sc.Forward(); + + if (sc.Match("\begin{code}")) { + sc.Forward(static_cast<int>(strlen("\begin{code}"))); + + bool correct = true; + + while (!sc.atLineEnd && sc.More()) { + if (sc.ch != ' ' && sc.ch != '\t') { + correct = false; + } + sc.Forward(); + } + + if (correct) { + sc.ChangeState(SCE_HA_LITERATE_CODEDELIM); // color the line end + hs.lmode = LITERATE_BLOCK; + } + } + } + else if (literate && hs.lmode == LITERATE_BLOCK && sc.atLineStart + && sc.Match("\end{code}")) { + sc.SetState(SCE_HA_LITERATE_CODEDELIM); + + sc.Forward(static_cast<int>(strlen("\end{code}"))); + + while (!sc.atLineEnd && sc.More()) { + sc.Forward(); + } + + sc.SetState(SCE_HA_LITERATE_COMMENT); + hs.lmode = LITERATE_BIRD; + } + // Preprocessor + else if (sc.atLineStart && sc.ch == '#' && options.cpp) { + sc.SetState(SCE_HA_PREPROCESSOR); + sc.Forward(); + } + // Literate + else if (sc.state == SCE_HA_LITERATE_COMMENT) { + sc.Forward(); + } + else if (sc.state == SCE_HA_LITERATE_CODEDELIM) { + sc.ForwardSetState(hs.nonexternalStyle); + } + // Preprocessor + else if (sc.state == SCE_HA_PREPROCESSOR) { + if (sc.atLineEnd) { + sc.SetState(options.stylingWithinPreprocessor + ? SCE_HA_DEFAULT + : hs.nonexternalStyle); + sc.Forward(); // prevent double counting a line + } else if (options.stylingWithinPreprocessor && !IsHaskellLetter(sc.ch)) { + sc.SetState(SCE_HA_DEFAULT); + } else { + sc.Forward(); + } + } + // Haskell // Operator - if (sc.state == SCE_HA_OPERATOR) { + else if (sc.state == SCE_HA_OPERATOR) { int style = SCE_HA_OPERATOR;

- if (sc.ch == ':' && + if ( sc.ch == ':' + && !alreadyInTheMiddleOfOperator // except "::" - !(sc.chNext == ':' && !IsAnOperatorChar(sc.GetRelative(2)))) { + && !( sc.chNext == ':' + && !IsAnHaskellOperatorChar(sc.GetRelative(2)))) { style = SCE_HA_CAPITAL; }

- while(IsAnOperatorChar(sc.ch)) + alreadyInTheMiddleOfOperator = false; + + while (IsAnHaskellOperatorChar(sc.ch)) sc.Forward();

- styler.ColourTo(sc.currentPos - 1, style); - sc.ChangeState(SCE_HA_DEFAULT); + char s[100]; + sc.GetCurrent(s, sizeof(s)); + + if (reserved_operators.InList(s)) + style = SCE_HA_RESERVED_OPERATOR; + + sc.ChangeState(style); + sc.SetState(SCE_HA_DEFAULT); } // String else if (sc.state == SCE_HA_STRING) { - if (sc.ch == '"') { + if (sc.atLineEnd) { + sc.ChangeState(SCE_HA_STRINGEOL); + sc.ForwardSetState(SCE_HA_DEFAULT); + } else if (sc.ch == '"') { sc.Forward(); + skipMagicHash(sc, oneHash); sc.SetState(SCE_HA_DEFAULT); } else if (sc.ch == '\') { sc.Forward(2); - } else if (sc.atLineEnd) { - sc.SetState(SCE_HA_DEFAULT); } else { sc.Forward(); } } // Char else if (sc.state == SCE_HA_CHARACTER) { - if (sc.ch == ''') { + if (sc.atLineEnd) { + sc.ChangeState(SCE_HA_STRINGEOL); + sc.ForwardSetState(SCE_HA_DEFAULT); + } else if (sc.ch == ''') { sc.Forward(); + skipMagicHash(sc, oneHash); sc.SetState(SCE_HA_DEFAULT); } else if (sc.ch == '\') { sc.Forward(2); - } else if (sc.atLineEnd) { - sc.SetState(SCE_HA_DEFAULT); } else { sc.Forward(); } } // Number else if (sc.state == SCE_HA_NUMBER) { - if (IsADigit(sc.ch, xmode) || - (sc.ch=='.' && IsADigit(sc.chNext, xmode))) { + if (sc.atLineEnd) { + sc.SetState(SCE_HA_DEFAULT); + sc.Forward(); // prevent double counting a line + } else if (IsADigit(sc.ch, base)) { sc.Forward(); - } else if ((xmode == 10) && + } else if (sc.ch=='.' && dot && IsADigit(sc.chNext, base)) { + sc.Forward(2); + dot = false; + } else if ((base == 10) && (sc.ch == 'e' || sc.ch == 'E') && (IsADigit(sc.chNext) || sc.chNext == '+' || sc.chNext == '-')) { sc.Forward(); if (sc.ch == '+' || sc.ch == '-') sc.Forward(); } else { + skipMagicHash(sc, twoHashes); sc.SetState(SCE_HA_DEFAULT); } } // Keyword or Identifier else if (sc.state == SCE_HA_IDENTIFIER) { + int style = IsHaskellUpperCase(sc.ch) ? SCE_HA_CAPITAL : SCE_HA_IDENTIFIER; + + assert(IsAHaskellWordStart(sc.ch)); + + sc.Forward(); + while (sc.More()) { - if (IsAWordChar(sc.ch, magicHash)) { + if (IsAHaskellWordChar(sc.ch)) { sc.Forward(); - } else if (xmode == SCE_HA_CAPITAL && sc.ch=='.') { - if (isupper(sc.chNext)) { - xmode = SCE_HA_CAPITAL; + } else if (sc.ch == '.' && style == SCE_HA_CAPITAL) { + if (IsHaskellUpperCase(sc.chNext)) { sc.Forward(); - } else if (IsAWordStart(sc.chNext)) { - xmode = SCE_HA_IDENTIFIER; + style = SCE_HA_CAPITAL; + } else if (IsAHaskellWordStart(sc.chNext)) { sc.Forward(); - } else if (IsAnOperatorChar(sc.chNext)) { - xmode = SCE_HA_OPERATOR; + style = SCE_HA_IDENTIFIER; + } else if (IsAnHaskellOperatorChar(sc.chNext)) { sc.Forward(); + style = sc.ch == ':' ? SCE_HA_CAPITAL : SCE_HA_OPERATOR; + while (IsAnHaskellOperatorChar(sc.ch)) + sc.Forward(); + break; } else { break; } - } else if (xmode == SCE_HA_OPERATOR && IsAnOperatorChar(sc.ch)) { - sc.Forward(); } else { break; } }

+ skipMagicHash(sc, unlimitedHashes); + char s[100]; sc.GetCurrent(s, sizeof(s));

- int style = xmode; - - int new_mode = HA_MODE_DEFAULT; + KeywordMode new_mode = HA_MODE_DEFAULT;

if (keywords.InList(s)) { style = SCE_HA_KEYWORD; - } else if (isupper(s[0])) { - if (mode >= HA_MODE_IMPORT1 && mode <= HA_MODE_IMPORT3) { + } else if (style == SCE_HA_CAPITAL) { + if (hs.mode == HA_MODE_IMPORT1 || hs.mode == HA_MODE_IMPORT3) { style = SCE_HA_MODULE; new_mode = HA_MODE_IMPORT2; - } else if (mode == HA_MODE_MODULE) { + } else if (hs.mode == HA_MODE_MODULE) { style = SCE_HA_MODULE; } - } else if (mode == HA_MODE_IMPORT1 && + } else if (hs.mode == HA_MODE_IMPORT1 && strcmp(s,"qualified") == 0) { style = SCE_HA_KEYWORD; new_mode = HA_MODE_IMPORT1; - } else if (mode == HA_MODE_IMPORT2) { + } else if (options.highlightSafe && + hs.mode == HA_MODE_IMPORT1 && + strcmp(s,"safe") == 0) { + style = SCE_HA_KEYWORD; + new_mode = HA_MODE_IMPORT1; + } else if (hs.mode == HA_MODE_IMPORT2) { if (strcmp(s,"as") == 0) { style = SCE_HA_KEYWORD; new_mode = HA_MODE_IMPORT3; } else if (strcmp(s,"hiding") == 0) { style = SCE_HA_KEYWORD; } - } else if (mode == HA_MODE_TYPE) { + } else if (hs.mode == HA_MODE_TYPE) { if (strcmp(s,"family") == 0) style = SCE_HA_KEYWORD; }

- if (mode == HA_MODE_FFI) { + if (hs.mode == HA_MODE_FFI) { if (ffi.InList(s)) { style = SCE_HA_KEYWORD; new_mode = HA_MODE_FFI; } }

- styler.ColourTo(sc.currentPos - 1, style); + sc.ChangeState(style); + sc.SetState(SCE_HA_DEFAULT);

- if (strcmp(s,"import") == 0 && mode != HA_MODE_FFI) + if (strcmp(s,"import") == 0 && hs.mode != HA_MODE_FFI) new_mode = HA_MODE_IMPORT1; else if (strcmp(s,"module") == 0) new_mode = HA_MODE_MODULE; @@ -235,87 +788,88 @@ static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle, || strcmp(s,"data") == 0) new_mode = HA_MODE_TYPE;

- xmode = 0; - sc.ChangeState(SCE_HA_DEFAULT); - mode = new_mode; + hs.mode = new_mode; }

// Comments // Oneliner else if (sc.state == SCE_HA_COMMENTLINE) { - if (xmode == 1 && sc.ch != '-') { - xmode = 0; - if (IsAnOperatorChar(sc.ch)) + if (sc.atLineEnd) { + sc.SetState(hs.pragma ? SCE_HA_PRAGMA : SCE_HA_DEFAULT); + sc.Forward(); // prevent double counting a line + } else if (inDashes && sc.ch != '-' && !hs.pragma) { + inDashes = false; + if (IsAnHaskellOperatorChar(sc.ch)) { + alreadyInTheMiddleOfOperator = true; sc.ChangeState(SCE_HA_OPERATOR); - } else if (sc.atLineEnd) { - sc.SetState(SCE_HA_DEFAULT); + } } else { sc.Forward(); } } // Nested - else if (sc.state == SCE_HA_COMMENTBLOCK) { + else if (IsCommentBlockStyle(sc.state)) { if (sc.Match('{','-')) { + sc.SetState(CommentBlockStyleFromNestLevel(hs.nestLevel)); sc.Forward(2); - xmode++; - } - else if (sc.Match('-','}')) { + hs.nestLevel++; + } else if (sc.Match('-','}')) { sc.Forward(2); - xmode--; - if (xmode == 0) { - sc.SetState(SCE_HA_DEFAULT); - } + assert(hs.nestLevel > 0); + if (hs.nestLevel > 0) + hs.nestLevel--; + sc.SetState( + hs.nestLevel == 0 + ? (hs.pragma ? SCE_HA_PRAGMA : SCE_HA_DEFAULT) + : CommentBlockStyleFromNestLevel(hs.nestLevel - 1)); } else { - if (sc.atLineEnd) { - // Remember the line state for future incremental lexing - styler.SetLineState(lineCurrent, (xmode << 4) | mode); - lineCurrent++; - } sc.Forward(); } } // Pragma else if (sc.state == SCE_HA_PRAGMA) { if (sc.Match("#-}")) { + hs.pragma = false; sc.Forward(3); sc.SetState(SCE_HA_DEFAULT); - } else { - sc.Forward(); - } - } - // Preprocessor - else if (sc.state == SCE_HA_PREPROCESSOR) { - if (stylingWithinPreprocessor && !IsAWordStart(sc.ch)) { - sc.SetState(SCE_HA_DEFAULT); - } else if (sc.ch == '\' && !stylingWithinPreprocessor) { + } else if (sc.Match('-','-')) { + sc.SetState(SCE_HA_COMMENTLINE); sc.Forward(2); - } else if (sc.atLineEnd) { - sc.SetState(SCE_HA_DEFAULT); + inDashes = false; + } else if (sc.Match('{','-')) { + sc.SetState(CommentBlockStyleFromNestLevel(hs.nestLevel)); + sc.Forward(2); + hs.nestLevel = 1; } else { sc.Forward(); } } - // New state? - if (sc.state == SCE_HA_DEFAULT) { + // New state? + else if (sc.state == SCE_HA_DEFAULT) { // Digit if (IsADigit(sc.ch)) { + hs.mode = HA_MODE_DEFAULT; + sc.SetState(SCE_HA_NUMBER); if (sc.ch == '0' && (sc.chNext == 'X' || sc.chNext == 'x')) { - // Match anything starting with "0x" or "0X", too - sc.Forward(2); - xmode = 16; + // Match anything starting with "0x" or "0X", too + sc.Forward(2); + base = 16; + dot = false; } else if (sc.ch == '0' && (sc.chNext == 'O' || sc.chNext == 'o')) { - // Match anything starting with "0x" or "0X", too - sc.Forward(2); - xmode = 8; + // Match anything starting with "0o" or "0O", too + sc.Forward(2); + base = 8; + dot = false; } else { - sc.Forward(); - xmode = 10; + sc.Forward(); + base = 10; + dot = true; } - mode = HA_MODE_DEFAULT; } // Pragma else if (sc.Match("{-#")) { + hs.pragma = true; sc.SetState(SCE_HA_PRAGMA); sc.Forward(3); } @@ -323,33 +877,65 @@ static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle, else if (sc.Match('-','-')) { sc.SetState(SCE_HA_COMMENTLINE); sc.Forward(2); - xmode = 1; + inDashes = true; } // Comment block else if (sc.Match('{','-')) { - sc.SetState(SCE_HA_COMMENTBLOCK); + sc.SetState(CommentBlockStyleFromNestLevel(hs.nestLevel)); sc.Forward(2); - xmode = 1; + hs.nestLevel = 1; } // String - else if (sc.Match('"')) { + else if (sc.ch == '"') { sc.SetState(SCE_HA_STRING); sc.Forward(); } - // Character - else if (sc.Match(''')) { + // Character or quoted name or promoted term + else if (sc.ch == ''') { + hs.mode = HA_MODE_DEFAULT; + sc.SetState(SCE_HA_CHARACTER); sc.Forward(); + + if (options.allowQuotes) { + // Quoted type ''T + if (sc.ch==''' && IsAHaskellWordStart(sc.chNext)) { + sc.Forward(); + sc.ChangeState(SCE_HA_IDENTIFIER); + } else if (sc.chNext != ''') { + // Quoted name 'n or promoted constructor 'N + if (IsAHaskellWordStart(sc.ch)) { + sc.ChangeState(SCE_HA_IDENTIFIER); + // Promoted constructor operator ':~> + } else if (sc.ch == ':') { + alreadyInTheMiddleOfOperator = false; + sc.ChangeState(SCE_HA_OPERATOR); + // Promoted list or tuple '[T] + } else if (sc.ch == '[' || sc.ch== '(') { + sc.ChangeState(SCE_HA_OPERATOR); + sc.ForwardSetState(SCE_HA_DEFAULT); + } + } + } } - // Preprocessor - else if (sc.atLineStart && sc.ch == '#') { - mode = HA_MODE_DEFAULT; - sc.SetState(SCE_HA_PREPROCESSOR); - sc.Forward(); + // Operator starting with '?' or an implicit parameter + else if (sc.ch == '?') { + hs.mode = HA_MODE_DEFAULT; + + alreadyInTheMiddleOfOperator = false; + sc.SetState(SCE_HA_OPERATOR); + + if ( options.implicitParams + && IsAHaskellWordStart(sc.chNext) + && !IsHaskellUpperCase(sc.chNext)) { + sc.Forward(); + sc.ChangeState(SCE_HA_IDENTIFIER); + } } // Operator - else if (IsAnOperatorChar(sc.ch)) { - mode = HA_MODE_DEFAULT; + else if (IsAnHaskellOperatorChar(sc.ch)) { + hs.mode = HA_MODE_DEFAULT; + sc.SetState(SCE_HA_OPERATOR); } // Braces and punctuation @@ -358,78 +944,171 @@ static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle, || sc.ch == '[' || sc.ch == ']' || sc.ch == '{' || sc.ch == '}') { sc.SetState(SCE_HA_OPERATOR); - sc.Forward(); - sc.SetState(SCE_HA_DEFAULT); + sc.ForwardSetState(SCE_HA_DEFAULT); } // Keyword or Identifier - else if (IsAWordStart(sc.ch)) { - xmode = isupper(sc.ch) ? SCE_HA_CAPITAL : SCE_HA_IDENTIFIER; + else if (IsAHaskellWordStart(sc.ch)) { sc.SetState(SCE_HA_IDENTIFIER); - sc.Forward(); + // Something we don't care about } else { - if (sc.atLineEnd) { - // Remember the line state for future incremental lexing - styler.SetLineState(lineCurrent, (xmode << 4) | mode); - lineCurrent++; - } sc.Forward(); } } + // This branch should never be reached. + else { + assert(false); + sc.Forward(); + } } + styler.SetLineState(lineCurrent, hs.ToLineState()); sc.Complete(); }

-// External stuff - used for dynamic-loading, not implemented in wxStyledTextCtrl yet. -// Inspired by the caml external lexer - Credits to Robert Roessler - http://www.rftp.com -#ifdef BUILD_EXTERNAL_LEXER -static const char* LexerName = "haskell"; - -void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length, int initStyle, - char *words[], WindowID window, char *props) -{ - PropSetSimple ps; - ps.SetMultiple(props); - WindowAccessor wa(window, ps); - - int nWL = 0; - for (; words[nWL]; nWL++) ; - WordList** wl = new WordList* [nWL + 1]; - int i = 0; - for (; i<nWL; i++) - { - wl[i] = new WordList(); - wl[i]->Set(words[i]); +void SCI_METHOD LexerHaskell::Fold(unsigned int startPos, int length, int // initStyle + ,IDocument *pAccess) { + if (!options.fold) + return; + + Accessor styler(pAccess, NULL); + + int lineCurrent = styler.GetLine(startPos); + + if (lineCurrent <= firstImportLine) { + firstImportLine = -1; // readjust first import position + firstImportIndent = 0; } - wl[i] = 0;

- ColorizeHaskellDoc(startPos, length, initStyle, wl, wa); - wa.Flush(); - for (i=nWL-1;i>=0;i--) - delete wl[i]; - delete [] wl; -} + const int maxPos = startPos + length; + const int maxLines = + maxPos == styler.Length() + ? styler.GetLine(maxPos) + : styler.GetLine(maxPos - 1); // Requested last line + const int docLines = styler.GetLine(styler.Length()); // Available last line

-void EXT_LEXER_DECL Fold (unsigned int lexer, unsigned int startPos, int length, int initStyle, - char *words[], WindowID window, char *props) -{ + // Backtrack to previous non-blank line so we can determine indent level + // for any white space lines + // and so we can fix any preceding fold level (which is why we go back + // at least one line in all cases) + bool importHere = LineContainsImport(lineCurrent, styler); + int indentCurrent = IndentAmountWithOffset(styler, lineCurrent);

-} + while (lineCurrent > 0) { + lineCurrent--; + importHere = LineContainsImport(lineCurrent, styler); + indentCurrent = IndentAmountWithOffset(styler, lineCurrent); + if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) + break; + }

-int EXT_LEXER_DECL GetLexerCount() -{ - return 1; -} + int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;

-void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength) -{ - if (buflength > 0) { - buflength--; - int n = strlen(LexerName); - if (n > buflength) - n = buflength; - memcpy(name, LexerName, n), name[n] = '\0'; + if (importHere) { + indentCurrentLevel = IndentLevelRemoveIndentOffset(indentCurrentLevel); + if (firstImportLine == -1) { + firstImportLine = lineCurrent; + firstImportIndent = (1 + indentCurrentLevel) - SC_FOLDLEVELBASE; + } + if (firstImportLine != lineCurrent) { + indentCurrentLevel++; + } } + + indentCurrent = indentCurrentLevel | (indentCurrent & ~SC_FOLDLEVELNUMBERMASK); + + // Process all characters to end of requested range + //that hangs over the end of the range. Cap processing in all cases + // to end of document. + while (lineCurrent <= docLines && lineCurrent <= maxLines) { + + // Gather info + int lineNext = lineCurrent + 1; + importHere = false; + int indentNext = indentCurrent; + + if (lineNext <= docLines) { + // Information about next line is only available if not at end of document + importHere = LineContainsImport(lineNext, styler); + indentNext = IndentAmountWithOffset(styler, lineNext); + } + if (indentNext & SC_FOLDLEVELWHITEFLAG) + indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel; + + // Skip past any blank lines for next indent level info; we skip also + // comments (all comments, not just those starting in column 0) + // which effectively folds them into surrounding code rather + // than screwing up folding. + + while (lineNext < docLines && (indentNext & SC_FOLDLEVELWHITEFLAG)) { + lineNext++; + importHere = LineContainsImport(lineNext, styler); + indentNext = IndentAmountWithOffset(styler, lineNext); + } + + int indentNextLevel = indentNext & SC_FOLDLEVELNUMBERMASK; + + if (importHere) { + indentNextLevel = IndentLevelRemoveIndentOffset(indentNextLevel); + if (firstImportLine == -1) { + firstImportLine = lineNext; + firstImportIndent = (1 + indentNextLevel) - SC_FOLDLEVELBASE; + } + if (firstImportLine != lineNext) { + indentNextLevel++; + } + } + + indentNext = indentNextLevel | (indentNext & ~SC_FOLDLEVELNUMBERMASK); + + const int levelBeforeComments = Maximum(indentCurrentLevel,indentNextLevel); + + // Now set all the indent levels on the lines we skipped + // Do this from end to start. Once we encounter one line + // which is indented more than the line after the end of + // the comment-block, use the level of the block before + + int skipLine = lineNext; + int skipLevel = indentNextLevel; + + while (--skipLine > lineCurrent) { + int skipLineIndent = IndentAmountWithOffset(styler, skipLine); + + if (options.foldCompact) { + if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > indentNextLevel) { + skipLevel = levelBeforeComments; + } + + int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG; + + styler.SetLevel(skipLine, skipLevel | whiteFlag); + } else { + if ( (skipLineIndent & SC_FOLDLEVELNUMBERMASK) > indentNextLevel + && !(skipLineIndent & SC_FOLDLEVELWHITEFLAG)) { + skipLevel = levelBeforeComments; + } + + styler.SetLevel(skipLine, skipLevel); + } + } + + int lev = indentCurrent; + + if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) { + if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) + lev |= SC_FOLDLEVELHEADERFLAG; + } + + // Set fold level for this line and move to next line + styler.SetLevel(lineCurrent, options.foldCompact ? lev : lev & ~SC_FOLDLEVELWHITEFLAG); + + indentCurrent = indentNext; + indentCurrentLevel = indentNextLevel; + lineCurrent = lineNext; + } + + // NOTE: Cannot set level of last line here because indentCurrent doesn't have + // header flag set; the loop above is crafted to take care of this case! + //styler.SetLevel(lineCurrent, indentCurrent); } -#endif

-LexerModule lmHaskell(SCLEX_HASKELL, ColorizeHaskellDoc, "haskell"); +LexerModule lmHaskell(SCLEX_HASKELL, LexerHaskell::LexerFactoryHaskell, "haskell", haskellWordListDesc); +LexerModule lmLiterateHaskell(SCLEX_LITERATEHASKELL, LexerHaskell::LexerFactoryLiterateHaskell, "literatehaskell", haskellWordListDesc);

Modified: scintilla/lexers/LexLaTeX.cxx 6 files changed, 3 insertions(+), 3 deletions(-) =================================================================== @@ -224,7 +224,7 @@ void SCI_METHOD LexerLaTeX::Lex(unsigned int startPos, int length, int initStyle chNext = styler.SafeGetCharAt(i + 1); } else if (chNext == '\r' || chNext == '\n') { styler.ColourTo(i, SCE_L_ERROR); - } else { + } else if (isascii(chNext)) { styler.ColourTo(i + 1, SCE_L_SHORTCMD); if (chNext == '(') { mode = 1; @@ -340,7 +340,7 @@ void SCI_METHOD LexerLaTeX::Lex(unsigned int startPos, int length, int initStyle chNext = styler.SafeGetCharAt(i + 1); } else if (chNext == '\r' || chNext == '\n') { styler.ColourTo(i, SCE_L_ERROR); - } else { + } else if (isascii(chNext)) { if (chNext == ')') { mode = 0; state = SCE_L_DEFAULT; @@ -382,7 +382,7 @@ void SCI_METHOD LexerLaTeX::Lex(unsigned int startPos, int length, int initStyle chNext = styler.SafeGetCharAt(i + 1); } else if (chNext == '\r' || chNext == '\n') { styler.ColourTo(i, SCE_L_ERROR); - } else { + } else if (isascii(chNext)) { if (chNext == ']') { mode = 0; state = SCE_L_DEFAULT;

Modified: scintilla/lexers/LexOthers.cxx 4 files changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -1047,10 +1047,10 @@ static int RecogniseErrorListLine(const char *lineBuffer, unsigned int lengthLin } } else if (state == stCtagsStart) { if ((lineBuffer[i - 1] == '\t') && - ((ch == '/' && lineBuffer[i + 1] == '^') || Is0To9(ch))) { + ((ch == '/' && chNext == '^') || Is0To9(ch))) { state = stCtags; break; - } else if ((ch == '/') && (lineBuffer[i + 1] == '^')) { + } else if ((ch == '/') && (chNext == '^')) { state = stCtagsStartString; } } else if ((state == stCtagsStartString) && ((lineBuffer[i] == '$') && (lineBuffer[i + 1] == '/'))) {

Modified: scintilla/lexlib/LexerModule.cxx 2 files changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -75,7 +75,7 @@ int LexerModule::GetNumWordLists() const {

const char *LexerModule::GetWordListDescription(int index) const { assert(index < GetNumWordLists()); - if (index >= GetNumWordLists()) { + if (!wordListDescriptions || (index >= GetNumWordLists())) { return ""; } else { return wordListDescriptions[index];

Modified: scintilla/lexlib/PropSetSimple.cxx 23 files changed, 7 insertions(+), 16 deletions(-) =================================================================== @@ -141,30 +141,21 @@ static int ExpandAllInPlace(const PropSetSimple &props, std::string &withVars, i return maxExpands; }

-char *PropSetSimple::Expanded(const char *key) const { +int PropSetSimple::GetExpanded(const char *key, char *result) const { std::string val = Get(key); ExpandAllInPlace(*this, val, 100, VarChain(key)); - char *ret = new char [val.size() + 1]; - strcpy(ret, val.c_str()); - return ret; -} - -int PropSetSimple::GetExpanded(const char *key, char *result) const { - char *val = Expanded(key); - const int n = static_cast<int>(strlen(val)); + const int n = static_cast<int>(val.size()); if (result) { - strcpy(result, val); + strcpy(result, val.c_str()); } - delete []val; return n; // Not including NUL }

int PropSetSimple::GetInt(const char *key, int defaultValue) const { - char *val = Expanded(key); - if (val) { - int retVal = val[0] ? atoi(val) : defaultValue; - delete []val; - return retVal; + std::string val = Get(key); + ExpandAllInPlace(*this, val, 100, VarChain(key)); + if (!val.empty()) { + return atoi(val.c_str()); } return defaultValue; }

Modified: scintilla/lexlib/PropSetSimple.h 1 files changed, 0 insertions(+), 1 deletions(-) =================================================================== @@ -21,7 +21,6 @@ class PropSetSimple { void Set(const char *key, const char *val, int lenKey=-1, int lenVal=-1); void SetMultiple(const char *); const char *Get(const char *key) const; - char *Expanded(const char *key) const; int GetExpanded(const char *key, char *result) const; int GetInt(const char *key, int defaultValue=0) const; };

Modified: scintilla/lexlib/StyleContext.h 4 files changed, 3 insertions(+), 1 deletions(-) =================================================================== @@ -76,7 +76,7 @@ class StyleContext { // End of line? // Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) // or on LF alone (Unix). Avoid triggering two times on Dos/Win. - if (lineStartNext < styler.Length()) + if (currentLine < lineDocEnd) atLineEnd = static_cast<int>(pos) >= (lineStartNext-1); else // Last line atLineEnd = static_cast<int>(pos) >= lineStartNext; @@ -85,6 +85,7 @@ class StyleContext { public: unsigned int currentPos; int currentLine; + int lineDocEnd; int lineStartNext; bool atLineStart; bool atLineEnd; @@ -112,6 +113,7 @@ class StyleContext { lengthDocument = static_cast<unsigned int>(styler.Length()); if (endPos == lengthDocument) endPos++; + lineDocEnd = styler.GetLine(lengthDocument); atLineStart = static_cast<unsigned int>(styler.LineStart(currentLine)) == startPos; unsigned int pos = currentPos; ch = static_cast<unsigned char>(styler.SafeGetCharAt(pos, 0));

Modified: scintilla/lexlib/WordList.cxx 51 files changed, 34 insertions(+), 17 deletions(-) =================================================================== @@ -45,29 +45,37 @@ static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = fa prev = curr; } char **keywords = new char *[words + 1]; - if (keywords) { - words = 0; - prev = '\0'; - size_t slen = strlen(wordlist); - for (size_t k = 0; k < slen; k++) { - if (!wordSeparator[static_cast<unsigned char>(wordlist[k])]) { - if (!prev) { - keywords[words] = &wordlist[k]; - words++; - } - } else { - wordlist[k] = '\0'; + words = 0; + prev = '\0'; + size_t slen = strlen(wordlist); + for (size_t k = 0; k < slen; k++) { + if (!wordSeparator[static_cast<unsigned char>(wordlist[k])]) { + if (!prev) { + keywords[words] = &wordlist[k]; + words++; } - prev = wordlist[k]; + } else { + wordlist[k] = '\0'; } - keywords[words] = &wordlist[slen]; - *len = words; - } else { - *len = 0; + prev = wordlist[k]; } + keywords[words] = &wordlist[slen]; + *len = words; return keywords; }

+WordList::WordList(bool onlyLineEnds_) : + words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) { +} + +WordList::~WordList() { + Clear(); +} + +WordList::operator bool() const { + return len ? true : false; +} + bool WordList::operator!=(const WordList &other) const { if (len != other.len) return true; @@ -78,6 +86,10 @@ bool WordList::operator!=(const WordList &other) const { return false; }

+int WordList::Length() const { + return len; +} + void WordList::Clear() { if (words) { delete []list; @@ -217,3 +229,8 @@ bool WordList::InListAbbreviated(const char *s, const char marker) const { } return false; } + +const char *WordList::WordAt(int n) const { + return words[n]; +} +

Modified: scintilla/lexlib/WordList.h 12 files changed, 6 insertions(+), 6 deletions(-) =================================================================== @@ -15,23 +15,23 @@ /** */ class WordList { -public: // Each word contains at least one character - a empty word acts as sentinel at the end. char **words; char *list; int len; bool onlyLineEnds; ///< Delimited by any white space or only line ends int starts[256]; - WordList(bool onlyLineEnds_ = false) : - words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) - {} - ~WordList() { Clear(); } - operator bool() const { return len ? true : false; } +public: + WordList(bool onlyLineEnds_ = false); + ~WordList(); + operator bool() const; bool operator!=(const WordList &other) const; + int Length() const; void Clear(); void Set(const char *s); bool InList(const char *s) const; bool InListAbbreviated(const char *s, const char marker) const; + const char *WordAt(int n) const; };

#ifdef SCI_NAMESPACE

Modified: scintilla/scintilla_changes.patch 3 files changed, 2 insertions(+), 1 deletions(-) =================================================================== @@ -31,7 +31,7 @@ diff --git b/scintilla/src/Catalogue.cxx a/scintilla/src/Catalogue.cxx index 2f75247..a34f834 100644 +++ scintilla/src/Catalogue.cxx --- scintilla/src/Catalogue.cxx -@@ -81,108 +81,45 @@ int Scintilla_LinkLexers() { +@@ -81,109 +81,45 @@ int Scintilla_LinkLexers() {

//++Autogenerated -- run src/LexGen.py to regenerate //**(\tLINK_LEXER(*);\n) @@ -82,6 +82,7 @@ index 2f75247..a34f834 100644 - LINK_LEXER(lmKix); LINK_LEXER(lmLatex); LINK_LEXER(lmLISP); +- LINK_LEXER(lmLiterateHaskell); - LINK_LEXER(lmLot); - LINK_LEXER(lmLout); LINK_LEXER(lmLua);

Modified: scintilla/src/CallTip.cxx 22 files changed, 9 insertions(+), 13 deletions(-) =================================================================== @@ -7,12 +7,14 @@

#include <stdlib.h> #include <string.h> +#include <stdio.h> + +#include <string>

#include "Platform.h"

#include "Scintilla.h" #include "CallTip.h" -#include <stdio.h>

#ifdef SCI_NAMESPACE using namespace Scintilla; @@ -22,7 +24,6 @@ wCallTip = 0; inCallTipMode = false; posStartCallTip = 0; - val = 0; rectUp = PRectangle(0,0,0,0); rectDown = PRectangle(0,0,0,0); lineHeight = 1; @@ -56,8 +57,6 @@ CallTip::~CallTip() { font.Release(); wCallTip.Destroy(); - delete []val; - val = 0; }

// Although this test includes 0, we should never see a \0 character. @@ -176,17 +175,17 @@ int CallTip::PaintContents(Surface *surfaceWindow, bool draw) { // Draw the definition in three parts: before highlight, highlighted, after highlight int ytext = rcClient.top + ascent + 1; rcClient.bottom = ytext + surfaceWindow->Descent(font) + 1; - char *chunkVal = val; + const char *chunkVal = val.c_str(); bool moreChunks = true; int maxWidth = 0;

while (moreChunks) { - char *chunkEnd = strchr(chunkVal, '\n'); + const char *chunkEnd = strchr(chunkVal, '\n'); if (chunkEnd == NULL) { chunkEnd = chunkVal + strlen(chunkVal); moreChunks = false; } - int chunkOffset = chunkVal - val; + int chunkOffset = chunkVal - val.c_str(); int chunkLength = chunkEnd - chunkVal; int chunkEndOffset = chunkOffset + chunkLength; int thisStartHighlight = Platform::Maximum(startHighlight, chunkOffset); @@ -215,7 +214,7 @@ int CallTip::PaintContents(Surface *surfaceWindow, bool draw) { }

void CallTip::PaintCT(Surface *surfaceWindow) { - if (!val) + if (val.empty()) return; PRectangle rcClientPos = wCallTip.GetClientPosition(); PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left, @@ -253,10 +252,7 @@ PRectangle CallTip::CallTipStart(int pos, Point pt, int textHeight, const char * int codePage_, int characterSet, int technology, Window &wParent) { clickPlace = 0; - delete []val; - val = 0; - val = new char[strlen(defn) + 1]; - strcpy(val, defn); + val = defn; codePage = codePage_; Surface *surfaceMeasure = Surface::Allocate(technology); if (!surfaceMeasure) @@ -275,7 +271,7 @@ PRectangle CallTip::CallTipStart(int pos, Point pt, int textHeight, const char * // Only support \n here - simply means container must avoid \r! int numLines = 1; const char *newline; - const char *look = val; + const char *look = val.c_str(); rectUp = PRectangle(0,0,0,0); rectDown = PRectangle(0,0,0,0); offsetMain = insetX; // changed to right edge of any arrows

Modified: scintilla/src/CallTip.h 2 files changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -17,7 +17,7 @@ class CallTip { int startHighlight; // character offset to start and... int endHighlight; // ...end of highlighted text - char *val; + std::string val; Font font; PRectangle rectUp; // rectangle of last up angle in the tip PRectangle rectDown; // rectangle of last down arrow in the tip

Modified: scintilla/src/CellBuffer.cxx 24 files changed, 12 insertions(+), 12 deletions(-) =================================================================== @@ -10,6 +10,8 @@ #include <stdlib.h> #include <stdarg.h>

+#include <algorithm> + #include "Platform.h"

#include "Scintilla.h" @@ -81,11 +83,15 @@ int LineVector::LineFromPosition(int pos) const { Destroy(); }

-void Action::Create(actionType at_, int position_, char *data_, int lenData_, bool mayCoalesce_) { +void Action::Create(actionType at_, int position_, const char *data_, int lenData_, bool mayCoalesce_) { delete []data; + data = NULL; position = position_; at = at_; - data = data_; + if (lenData_) { + data = new char[lenData_]; + memcpy(data, data_, lenData_); + } lenData = lenData_; mayCoalesce = mayCoalesce_; } @@ -162,7 +168,7 @@ void UndoHistory::EnsureUndoRoom() { } }

-void UndoHistory::AppendAction(actionType at, int position, char *data, int lengthData, +void UndoHistory::AppendAction(actionType at, int position, const char *data, int lengthData, bool &startSequence, bool mayCoalesce) { EnsureUndoRoom(); //Platform::DebugPrintf("%% %d action %d %d %d\n", at, position, lengthData, currentAction); @@ -393,11 +399,7 @@ const char *CellBuffer::InsertString(int position, const char *s, int insertLeng if (collectingUndo) { // Save into the undo/redo stack, but only the characters - not the formatting // This takes up about half load time - data = new char[insertLength]; - for (int i = 0; i < insertLength; i++) { - data[i] = s[i]; - } - uh.AppendAction(insertAction, position, data, insertLength, startSequence); + uh.AppendAction(insertAction, position, s, insertLength, startSequence); }

BasicInsertString(position, s, insertLength); @@ -439,10 +441,8 @@ const char *CellBuffer::DeleteChars(int position, int deleteLength, bool &startS if (!readOnly) { if (collectingUndo) { // Save into the undo/redo stack, but only the characters - not the formatting - data = new char[deleteLength]; - for (int i = 0; i < deleteLength; i++) { - data[i] = substance.ValueAt(position + i); - } + // The gap would be moved to position anyway for the deletion so this doesn't cost extra + const char *data = substance.RangePointer(position, deleteLength); uh.AppendAction(removeAction, position, data, deleteLength, startSequence); }

Modified: scintilla/src/CellBuffer.h 4 files changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -80,7 +80,7 @@ class Action {

Action(); ~Action(); - void Create(actionType at_, int position_=0, char *data_=0, int lenData_=0, bool mayCoalesce_=true); + void Create(actionType at_, int position_=0, const char *data_=0, int lenData_=0, bool mayCoalesce_=true); void Destroy(); void Grab(Action *source); }; @@ -105,7 +105,7 @@ class UndoHistory { UndoHistory(); ~UndoHistory();

- void AppendAction(actionType at, int position, char *data, int length, bool &startSequence, bool mayCoalesce=true); + void AppendAction(actionType at, int position, const char *data, int length, bool &startSequence, bool mayCoalesce=true);

void BeginUndoAction(); void EndUndoAction();

Modified: scintilla/src/ContractionState.cxx 2 files changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -7,6 +7,8 @@

#include <string.h>

+#include <algorithm> + #include "Platform.h"

#include "SplitVector.h"

Modified: scintilla/src/Decoration.cxx 2 files changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -9,6 +9,8 @@ #include <stdlib.h> #include <stdarg.h>

+#include <algorithm> + #include "Platform.h"

#include "Scintilla.h"

Modified: scintilla/src/Document.cxx 228 files changed, 66 insertions(+), 162 deletions(-) =================================================================== @@ -13,6 +13,7 @@

#include <string> #include <vector> +#include <algorithm>

#include "Platform.h"

@@ -102,8 +103,6 @@ int LexInterface::LineEndTypesSupported() { useTabs = true; tabIndents = true; backspaceUnindents = false; - watchers = 0; - lenWatchers = 0;

matchesValid = false; regex = 0; @@ -122,16 +121,13 @@ int LexInterface::LineEndTypesSupported() { }

Document::~Document() { - for (int i = 0; i < lenWatchers; i++) { - watchers[i].watcher->NotifyDeleted(this, watchers[i].userData); + for (std::vector<WatcherWithUserData>::iterator it = watchers.begin(); it != watchers.end(); ++it) { + it->watcher->NotifyDeleted(this, it->userData); } - delete []watchers; for (int j=0; j<ldSize; j++) { delete perLineData[j]; perLineData[j] = 0; } - watchers = 0; - lenWatchers = 0; delete regex; regex = 0; delete pli; @@ -309,9 +305,9 @@ int SCI_METHOD Document::LineEnd(int line) const { }

void SCI_METHOD Document::SetErrorStatus(int status) { - // Tell the watchers the lexer has changed. - for (int i = 0; i < lenWatchers; i++) { - watchers[i].watcher->NotifyErrorOccurred(this, watchers[i].userData, status); + // Tell the watchers an error has occurred. + for (std::vector<WatcherWithUserData>::iterator it = watchers.begin(); it != watchers.end(); ++it) { + it->watcher->NotifyErrorOccurred(this, it->userData, status); } }

@@ -420,7 +416,7 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in int lookLine = line; int lookLineLevel = level; int lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK; - while ((lookLine > 0) && ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) || + while ((lookLine > 0) && ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) || ((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum >= (GetLevel(lookLine + 1) & SC_FOLDLEVELNUMBERMASK))))) { lookLineLevel = GetLevel(--lookLine); lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK; @@ -453,8 +449,8 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in } } if (firstChangeableLineBefore == -1) { - for (lookLine = line - 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK; - lookLine >= beginFoldBlock; + for (lookLine = line - 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK; + lookLine >= beginFoldBlock; lookLineLevel = GetLevel(--lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK) { if ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) || (lookLineLevelNum > (level & SC_FOLDLEVELNUMBERMASK))) { firstChangeableLineBefore = lookLine; @@ -466,8 +462,8 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in firstChangeableLineBefore = beginFoldBlock - 1;

int firstChangeableLineAfter = -1; - for (lookLine = line + 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK; - lookLine <= endFoldBlock; + for (lookLine = line + 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK; + lookLine <= endFoldBlock; lookLineLevel = GetLevel(++lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK) { if ((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum < (GetLevel(lookLine + 1) & SC_FOLDLEVELNUMBERMASK))) { firstChangeableLineAfter = lookLine; @@ -715,7 +711,7 @@ bool SCI_METHOD Document::IsDBCSLeadByte(char ch) const { // Shift_jis return ((uch >= 0x81) && (uch <= 0x9F)) || ((uch >= 0xE0) && (uch <= 0xFC)); - // Lead bytes F0 to FC may be a Microsoft addition. + // Lead bytes F0 to FC may be a Microsoft addition. case 936: // GBK return (uch >= 0x81) && (uch <= 0xFE); @@ -892,7 +888,7 @@ void * SCI_METHOD Document::ConvertToDocument() { int Document::Undo() { int newPos = -1; CheckReadOnly(); - if (enteredModification == 0) { + if ((enteredModification == 0) && (cb.IsCollectingUndo())) { enteredModification++; if (!cb.IsReadOnly()) { bool startSavePoint = cb.IsSavePoint(); @@ -977,7 +973,7 @@ int Document::Undo() { int Document::Redo() { int newPos = -1; CheckReadOnly(); - if (enteredModification == 0) { + if ((enteredModification == 0) && (cb.IsCollectingUndo())) { enteredModification++; if (!cb.IsReadOnly()) { bool startSavePoint = cb.IsSavePoint(); @@ -1050,11 +1046,6 @@ bool Document::InsertCString(int position, const char *s) { return InsertString(position, s, static_cast<int>(s ? strlen(s) : 0)); }

-void Document::ChangeChar(int pos, char ch) { - DeleteChars(pos, 1); - InsertChar(pos, ch); -} - void Document::DelChar(int pos) {@@ Diff output truncated at 100000 characters. @@

-------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).