Branch: refs/heads/master Author: Colomban Wendling ban@herbesfolles.org Committer: Colomban Wendling ban@herbesfolles.org Date: Sat, 17 May 2014 20:23:43 UTC Commit: e566435dfae4e410f65efbb463f682221788354c https://github.com/geany/geany/commit/e566435dfae4e410f65efbb463f68222178835...

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

This fixes flickering under GTK >= 3.10.

Modified Paths: -------------- data/filetypes.c scintilla/gtk/ScintillaGTK.cxx scintilla/include/Platform.h scintilla/include/SciLexer.h scintilla/include/Scintilla.h scintilla/include/Scintilla.iface scintilla/lexers/LexCPP.cxx scintilla/lexers/LexHTML.cxx scintilla/lexers/LexLua.cxx scintilla/lexlib/LexerModule.h scintilla/lexlib/PropSetSimple.cxx scintilla/scintilla_changes.patch scintilla/src/CallTip.cxx scintilla/src/CharClassify.cxx scintilla/src/ContractionState.cxx scintilla/src/ContractionState.h scintilla/src/Document.cxx scintilla/src/Document.h scintilla/src/Editor.cxx scintilla/src/Editor.h scintilla/src/Indicator.cxx scintilla/src/LineMarker.cxx scintilla/src/PositionCache.cxx scintilla/src/PositionCache.h scintilla/src/RESearch.cxx scintilla/src/ScintillaBase.cxx scintilla/src/Selection.cxx scintilla/src/Selection.h scintilla/src/ViewStyle.cxx scintilla/src/ViewStyle.h scintilla/src/XPM.cxx scintilla/version.txt src/highlighting.c src/highlightingmappings.h

Modified: data/filetypes.c 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -28,6 +28,8 @@ globalclass=class # """verbatim""" tripleverbatim=string_2 hashquotedstring=string_2 +taskmarker=comment +escapesequence=string_1

[keywords] # all items must be in one line

Modified: scintilla/gtk/ScintillaGTK.cxx 65 lines changed, 44 insertions(+), 21 deletions(-) =================================================================== @@ -160,6 +160,7 @@ class ScintillaGTK : public ScintillaBase { #else GdkRegion *rgnUpdate; #endif + bool repaintFullWindow;

// Private so ScintillaGTK objects can not be copied ScintillaGTK(const ScintillaGTK &); @@ -172,6 +173,7 @@ class ScintillaGTK : public ScintillaBase { private: virtual void Initialise(); virtual void Finalise(); + virtual bool AbandonPaint(); virtual void DisplayCursor(Window::Cursor c); virtual bool DragThreshold(Point ptStart, Point ptNow); virtual void StartDrag(); @@ -309,7 +311,7 @@ class ScintillaGTK : public ScintillaBase { #endif static gboolean PressCT(GtkWidget *widget, GdkEventButton *event, ScintillaGTK *sciThis);

- static sptr_t DirectFunction(ScintillaGTK *sciThis, + static sptr_t DirectFunction(sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam); };

@@ -365,7 +367,8 @@ ScintillaGTK::ScintillaGTK(_ScintillaObject *sci_) : im_context(NULL), lastWheelMouseDirection(0), wheelMouseIntensity(0), - rgnUpdate(0) { + rgnUpdate(0), + repaintFullWindow(false) { sci = sci_; wMain = GTK_WIDGET(sci);

@@ -756,10 +759,10 @@ void ScintillaGTK::Initialise() { #else g_signal_connect(G_OBJECT(widtxt), "expose_event", G_CALLBACK(ScintillaGTK::ExposeText), this); -#endif - gtk_widget_set_events(widtxt, GDK_EXPOSURE_MASK); // Avoid background drawing flash gtk_widget_set_double_buffered(widtxt, FALSE); +#endif + gtk_widget_set_events(widtxt, GDK_EXPOSURE_MASK); gtk_widget_set_size_request(widtxt, 100, 100); adjustmentv = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 201.0, 1.0, 20.0, 20.0)); #if GTK_CHECK_VERSION(3,0,0) @@ -825,6 +828,13 @@ void ScintillaGTK::Finalise() { ScintillaBase::Finalise(); }

+bool ScintillaGTK::AbandonPaint() { + if ((paintState == painting) && !paintingAllText) { + repaintFullWindow = true; + } + return false; +} + void ScintillaGTK::DisplayCursor(Window::Cursor c) { if (cursorMode == SC_CURSORNORMAL) wText.SetCursor(c); @@ -842,11 +852,20 @@ void ScintillaGTK::StartDrag() { dragWasDropped = false; inDragDrop = ddDragging; GtkTargetList *tl = gtk_target_list_new(clipboardCopyTargets, nClipboardCopyTargets); +#if GTK_CHECK_VERSION(3,10,0) + gtk_drag_begin_with_coordinates(GTK_WIDGET(PWidget(wMain)), + tl, + static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE), + evbtn->button, + reinterpret_cast<GdkEvent *>(evbtn), + -1, -1); +#else gtk_drag_begin(GTK_WIDGET(PWidget(wMain)), tl, static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE), evbtn->button, reinterpret_cast<GdkEvent *>(evbtn)); +#endif }

static std::string ConvertText(const char *s, size_t len, const char *charSetDest, @@ -1189,7 +1208,7 @@ bool ScintillaGTK::ModifyScrollBars(int nMax, int nPage) { } #endif if (modified && (paintState == painting)) { - paintState = paintAbandoned; + repaintFullWindow = true; }

return modified; @@ -1487,7 +1506,7 @@ void ScintillaGTK::GetGtkSelectionText(GtkSelectionData *selectionData, Selectio len--; // Forget the extra '\0' #endif

- std::string dest = Document::TransformLineEnds(data, len, pdoc->eolMode); + std::string dest(data, len); if (selectionTypeData == GDK_TARGET_STRING) { if (IsUnicodeMode()) { // Unknown encoding so assume in Latin1 @@ -1528,15 +1547,9 @@ void ScintillaGTK::ReceivedSelection(GtkSelectionData *selection_data) { if (SelectionOfGSD(selection_data) != GDK_SELECTION_PRIMARY) { ClearSelection(multiPasteMode == SC_MULTIPASTE_EACH); } - SelectionPosition selStart = sel.IsRectangular() ? - sel.Rectangular().Start() : - sel.Range(sel.Main()).Start();

- if (selText.rectangular) { - PasteRectangular(selStart, selText.Data(), selText.Length()); - } else { - InsertPaste(selStart, selText.Data(), selText.Length()); - } + InsertPasteShape(selText.Data(), selText.Length(), + selText.rectangular ? pasteRectangular : pasteStream); EnsureCaretVisible(); } } @@ -1667,9 +1680,9 @@ void ScintillaGTK::Resize(int width, int height) { // Not always needed, but some themes can have different sizes of scrollbars #if GTK_CHECK_VERSION(3,0,0) GtkRequisition requisition; - gtk_widget_get_requisition(PWidget(scrollbarv), &requisition); + gtk_widget_get_preferred_size(PWidget(scrollbarv), NULL, &requisition); verticalScrollBarWidth = requisition.width; - gtk_widget_get_requisition(PWidget(scrollbarh), &requisition); + gtk_widget_get_preferred_size(PWidget(scrollbarh), NULL, &requisition); horizontalScrollBarHeight = requisition.height; #else verticalScrollBarWidth = GTK_WIDGET(PWidget(scrollbarv))->requisition.width; @@ -2168,8 +2181,9 @@ gboolean ScintillaGTK::KeyThis(GdkEventKey *event) { //fprintf(stderr, "SK-key: %d %x %x\n",event->keyval, event->state, consumed); if (event->keyval == 0xffffff && event->length > 0) { ClearSelection(); - if (pdoc->InsertCString(CurrentPosition(), event->string)) { - MovePositionTo(CurrentPosition() + event->length); + const int lengthInserted = pdoc->InsertString(CurrentPosition(), event->string, strlen(event->string)); + if (lengthInserted > 0) { + MovePositionTo(CurrentPosition() + lengthInserted); } } return consumed; @@ -2370,6 +2384,7 @@ void ScintillaGTK::Destroy(GObject *object) { gboolean ScintillaGTK::DrawTextThis(cairo_t *cr) { try { paintState = painting; + repaintFullWindow = false;

rcPaint = GetClientRectangle();

@@ -2397,11 +2412,12 @@ gboolean ScintillaGTK::DrawTextThis(cairo_t *cr) { surfaceWindow->Release(); delete surfaceWindow; } - if (paintState == paintAbandoned) { + if ((paintState == paintAbandoned) || repaintFullWindow) { // Painting area was insufficient to cover new styling or brace highlight positions FullPaint(); } paintState = notPainting; + repaintFullWindow = false;

if (rgnUpdate) { cairo_rectangle_list_destroy(rgnUpdate); @@ -2425,6 +2441,13 @@ gboolean ScintillaGTK::DrawThis(cairo_t *cr) { GTK_CONTAINER(PWidget(wMain)), PWidget(scrollbarh), cr); gtk_container_propagate_draw( GTK_CONTAINER(PWidget(wMain)), PWidget(scrollbarv), cr); +// Starting from the following version, the expose event are not propagated +// for double buffered non native windows, so we need to call it ourselves +// or keep the default handler +#if GTK_CHECK_VERSION(3,9,2) + gtk_container_propagate_draw( + GTK_CONTAINER(PWidget(wMain)), PWidget(wText), cr); +#endif } catch (...) { errorStatus = SC_STATUS_FAILURE; } @@ -2788,8 +2811,8 @@ gboolean ScintillaGTK::ExposeCT(GtkWidget *widget, GdkEventExpose * /*ose*/, Cal #endif

sptr_t ScintillaGTK::DirectFunction( - ScintillaGTK *sciThis, unsigned int iMessage, uptr_t wParam, sptr_t lParam) { - return sciThis->WndProc(iMessage, wParam, lParam); + sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam) { + return reinterpret_cast<ScintillaGTK *>(ptr)->WndProc(iMessage, wParam, lParam); }

sptr_t scintilla_send_message(ScintillaObject *sci, unsigned int iMessage, uptr_t wParam, sptr_t lParam) {

Modified: scintilla/include/Platform.h 24 lines changed, 15 insertions(+), 9 deletions(-) =================================================================== @@ -77,7 +77,9 @@ namespace Scintilla {

typedef float XYPOSITION; typedef double XYACCUMULATOR; -//#define XYPOSITION int +inline int RoundXYPosition(XYPOSITION xyPos) { + return int(xyPos + 0.5); +}

// Underlying the implementation of the platform classes are platform specific types. // Sometimes these need to be passed around by client code so they are defined here @@ -92,7 +94,7 @@ typedef void *IdlerID;

/** * A geometric point class. - * Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably. + * Point is similar to the Win32 POINT and GTK+ GdkPoint types. */ class Point { public: @@ -102,6 +104,10 @@ class Point { explicit Point(XYPOSITION x_=0, XYPOSITION y_=0) : x(x_), y(y_) { }

+ static Point FromInts(int x_, int y_) { + return Point(static_cast<XYPOSITION>(x_), static_cast<XYPOSITION>(y_)); + } + // Other automatically defined methods (assignment, copy constructor, destructor) are fine

static Point FromLong(long lpoint); @@ -109,7 +115,7 @@ class Point {

/** * A geometric rectangle class. - * PRectangle is exactly the same as the Win32 RECT so can be used interchangeably. + * PRectangle is similar to the Win32 RECT. * PRectangles contain their top and left sides, but not their right and bottom sides. */ class PRectangle { @@ -119,10 +125,15 @@ class PRectangle { XYPOSITION right; XYPOSITION bottom;

- PRectangle(XYPOSITION left_=0, XYPOSITION top_=0, XYPOSITION right_=0, XYPOSITION bottom_ = 0) : + explicit PRectangle(XYPOSITION left_=0, XYPOSITION top_=0, XYPOSITION right_=0, XYPOSITION bottom_ = 0) : left(left_), top(top_), right(right_), bottom(bottom_) { }

+ static PRectangle FromInts(int left_, int top_, int right_, int bottom_) { + return PRectangle(static_cast<XYPOSITION>(left_), static_cast<XYPOSITION>(top_), + static_cast<XYPOSITION>(right_), static_cast<XYPOSITION>(bottom_)); + } + // Other automatically defined methods (assignment, copy constructor, destructor) are fine

bool operator==(PRectangle &rc) const { @@ -516,11 +527,6 @@ class Platform { } #endif

-// Shut up annoying Visual C++ warnings: -#ifdef _MSC_VER -#pragma warning(disable: 4244 4309 4514 4710) -#endif - #if defined(__GNUC__) && defined(SCINTILLA_QT) #pragma GCC diagnostic ignored "-Wmissing-field-initializers" #endif

Modified: scintilla/include/SciLexer.h 13 lines changed, 13 insertions(+), 0 deletions(-) =================================================================== @@ -126,6 +126,7 @@ #define SCLEX_RUST 111 #define SCLEX_DMAP 112 #define SCLEX_AS 113 +#define SCLEX_DMIS 114 #define SCLEX_AUTOMATIC 1000 #define SCE_P_DEFAULT 0 #define SCE_P_COMMENTLINE 1 @@ -169,6 +170,8 @@ #define SCE_C_PREPROCESSORCOMMENT 23 #define SCE_C_PREPROCESSORCOMMENTDOC 24 #define SCE_C_USERLITERAL 25 +#define SCE_C_TASKMARKER 26 +#define SCE_C_ESCAPESEQUENCE 27 #define SCE_D_DEFAULT 0 #define SCE_D_COMMENT 1 #define SCE_D_COMMENTLINE 2 @@ -1700,6 +1703,16 @@ #define SCE_DMAP_WORD 8 #define SCE_DMAP_WORD2 9 #define SCE_DMAP_WORD3 10 +#define SCE_DMIS_DEFAULT 0 +#define SCE_DMIS_COMMENT 1 +#define SCE_DMIS_STRING 2 +#define SCE_DMIS_NUMBER 3 +#define SCE_DMIS_KEYWORD 4 +#define SCE_DMIS_MAJORWORD 5 +#define SCE_DMIS_MINORWORD 6 +#define SCE_DMIS_UNSUPPORTED_MAJOR 7 +#define SCE_DMIS_UNSUPPORTED_MINOR 8 +#define SCE_DMIS_LABEL 9 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */

#endif

Modified: scintilla/include/Scintilla.h 5 lines changed, 4 insertions(+), 1 deletions(-) =================================================================== @@ -50,6 +50,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, #define SCI_ADDTEXT 2001 #define SCI_ADDSTYLEDTEXT 2002 #define SCI_INSERTTEXT 2003 +#define SCI_CHANGEINSERTION 2672 #define SCI_CLEARALL 2004 #define SCI_DELETERANGE 2645 #define SCI_CLEARDOCUMENTSTYLE 2005 @@ -461,6 +462,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, #define SC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008 #define SC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010 #define SC_FOLDFLAG_LEVELNUMBERS 0x0040 +#define SC_FOLDFLAG_LINESTATE 0x0080 #define SCI_SETFOLDFLAGS 2233 #define SCI_ENSUREVISIBLEENFORCEPOLICY 2234 #define SCI_SETTABINDENTS 2260 @@ -945,7 +947,8 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, #define SC_MOD_CHANGEANNOTATION 0x20000 #define SC_MOD_CONTAINER 0x40000 #define SC_MOD_LEXERSTATE 0x80000 -#define SC_MODEVENTMASKALL 0xFFFFF +#define SC_MOD_INSERTCHECK 0x100000 +#define SC_MODEVENTMASKALL 0x1FFFFF #define SC_UPDATE_CONTENT 0x1 #define SC_UPDATE_SELECTION 0x2 #define SC_UPDATE_V_SCROLL 0x4

Modified: scintilla/include/Scintilla.iface 22 lines changed, 21 insertions(+), 1 deletions(-) =================================================================== @@ -98,6 +98,9 @@ fun void AddStyledText=2002(int length, cells c) # Insert string at a position. fun void InsertText=2003(position pos, string text)

+# Change the text that is being inserted in response to SC_MOD_INSERTCHECK +fun void ChangeInsertion=2672(int length, string text) + # Delete all text in the document. fun void ClearAll=2004(,)

@@ -1151,6 +1154,7 @@ val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004 val SC_FOLDFLAG_LINEAFTER_EXPANDED=0x0008 val SC_FOLDFLAG_LINEAFTER_CONTRACTED=0x0010 val SC_FOLDFLAG_LEVELNUMBERS=0x0040 +val SC_FOLDFLAG_LINESTATE=0x0080

# Set some style options for folding. set void SetFoldFlags=2233(int flags,) @@ -2494,7 +2498,8 @@ val SC_MOD_CHANGEMARGIN=0x10000 val SC_MOD_CHANGEANNOTATION=0x20000 val SC_MOD_CONTAINER=0x40000 val SC_MOD_LEXERSTATE=0x80000 -val SC_MODEVENTMASKALL=0xFFFFF +val SC_MOD_INSERTCHECK=0x100000 +val SC_MODEVENTMASKALL=0x1FFFFF

enu Update=SC_UPDATE_ val SC_UPDATE_CONTENT=0x1 @@ -2659,6 +2664,7 @@ val SCLEX_KVIRC=110 val SCLEX_RUST=111 val SCLEX_DMAP=112 val SCLEX_AS=113 +val SCLEX_DMIS=114

# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a # value assigned in sequence from SCLEX_AUTOMATIC+1. @@ -2711,6 +2717,8 @@ val SCE_C_HASHQUOTEDSTRING=22 val SCE_C_PREPROCESSORCOMMENT=23 val SCE_C_PREPROCESSORCOMMENTDOC=24 val SCE_C_USERLITERAL=25 +val SCE_C_TASKMARKER=26 +val SCE_C_ESCAPESEQUENCE=27 # Lexical states for SCLEX_D lex D=SCLEX_D SCE_D_ val SCE_D_DEFAULT=0 @@ -4438,6 +4446,18 @@ val SCE_DMAP_IDENTIFIER=7 val SCE_DMAP_WORD=8 val SCE_DMAP_WORD2=9 val SCE_DMAP_WORD3=10 +# Lexical states for SCLEX_DMIS +lex DMIS=SCLEX_DMIS SCE_DMIS_ +val SCE_DMIS_DEFAULT=0 +val SCE_DMIS_COMMENT=1 +val SCE_DMIS_STRING=2 +val SCE_DMIS_NUMBER=3 +val SCE_DMIS_KEYWORD=4 +val SCE_DMIS_MAJORWORD=5 +val SCE_DMIS_MINORWORD=6 +val SCE_DMIS_UNSUPPORTED_MAJOR=7 +val SCE_DMIS_UNSUPPORTED_MINOR=8 +val SCE_DMIS_LABEL=9

# Events

Modified: scintilla/lexers/LexCPP.cxx 486 lines changed, 382 insertions(+), 104 deletions(-) =================================================================== @@ -36,7 +36,10 @@ using namespace Scintilla; #endif

-static bool IsSpaceEquiv(int state) { +namespace { + // Use an unnamed namespace to protect the functions and classes from name conflicts + +bool IsSpaceEquiv(int state) { return (state <= SCE_C_COMMENTDOC) || // including SCE_C_DEFAULT, SCE_C_COMMENT, SCE_C_COMMENTLINE (state == SCE_C_COMMENTLINEDOC) || (state == SCE_C_COMMENTDOCKEYWORD) || @@ -50,7 +53,7 @@ static bool IsSpaceEquiv(int state) { // a = b+++/ptn/... // Putting a space between the '++' post-inc operator and the '+' binary op // fixes this, and is highly recommended for readability anyway. -static bool FollowsPostfixOperator(StyleContext &sc, LexAccessor &styler) { +bool FollowsPostfixOperator(StyleContext &sc, LexAccessor &styler) { int pos = (int) sc.currentPos; while (--pos > 0) { char ch = styler[pos]; @@ -61,7 +64,7 @@ static bool FollowsPostfixOperator(StyleContext &sc, LexAccessor &styler) { return false; }

-static bool followsReturnKeyword(StyleContext &sc, LexAccessor &styler) { +bool followsReturnKeyword(StyleContext &sc, LexAccessor &styler) { // Don't look at styles, so no need to flush. int pos = (int) sc.currentPos; int currentLine = styler.GetLine(pos); @@ -83,7 +86,120 @@ static bool followsReturnKeyword(StyleContext &sc, LexAccessor &styler) { return !*s; }

-static std::string GetRestOfLine(LexAccessor &styler, int start, bool allowSpace) { +bool IsSpaceOrTab(int ch) { + return ch == ' ' || ch == '\t'; +} + +bool OnlySpaceOrTab(const std::string &s) { + for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) { + if (!IsSpaceOrTab(*it)) + return false; + } + return true; +} + +std::vectorstd::string StringSplit(const std::string &text, int separator) { + std::vectorstd::string vs(text.empty() ? 0 : 1); + for (std::string::const_iterator it = text.begin(); it != text.end(); ++it) { + if (*it == separator) { + vs.push_back(std::string()); + } else { + vs.back() += *it; + } + } + return vs; +} + +struct BracketPair { + std::vectorstd::string::iterator itBracket; + std::vectorstd::string::iterator itEndBracket; +}; + +BracketPair FindBracketPair(std::vectorstd::string &tokens) { + BracketPair bp; + std::vectorstd::string::iterator itTok = std::find(tokens.begin(), tokens.end(), "("); + bp.itBracket = tokens.end(); + bp.itEndBracket = tokens.end(); + if (itTok != tokens.end()) { + bp.itBracket = itTok; + size_t nest = 0; + while (itTok != tokens.end()) { + if (*itTok == "(") { + nest++; + } else if (*itTok == ")") { + nest--; + if (nest == 0) { + bp.itEndBracket = itTok; + return bp; + } + } + ++itTok; + } + } + bp.itBracket = tokens.end(); + return bp; +} + +void highlightTaskMarker(StyleContext &sc, LexAccessor &styler, + int activity, WordList &markerList, bool caseSensitive){ + if ((isoperator(sc.chPrev) || IsASpace(sc.chPrev)) && markerList.Length()) { + const int lengthMarker = 50; + char marker[lengthMarker+1]; + int currPos = (int) sc.currentPos; + int i = 0; + while (i < lengthMarker) { + char ch = styler.SafeGetCharAt(currPos + i); + if (IsASpace(ch) || isoperator(ch)) { + break; + } + if (caseSensitive) + marker[i] = ch; + else + marker[i] = static_cast<char>(tolower(ch)); + i++; + } + marker[i] = '\0'; + if (markerList.InList(marker)) { + sc.SetState(SCE_C_TASKMARKER|activity); + } + } +} + +struct EscapeSequence { + int digitsLeft; + CharacterSet setHexDigits; + CharacterSet setOctDigits; + CharacterSet setNoneNumeric; + CharacterSet *escapeSetValid; + EscapeSequence() { + digitsLeft = 0; + escapeSetValid = 0; + setHexDigits = CharacterSet(CharacterSet::setDigits, "ABCDEFabcdef"); + setOctDigits = CharacterSet(CharacterSet::setNone, "01234567"); + } + void resetEscapeState(int nextChar) { + digitsLeft = 0; + escapeSetValid = &setNoneNumeric; + if (nextChar == 'U') { + digitsLeft = 9; + escapeSetValid = &setHexDigits; + } else if (nextChar == 'u') { + digitsLeft = 5; + escapeSetValid = &setHexDigits; + } else if (nextChar == 'x') { + digitsLeft = 5; + escapeSetValid = &setHexDigits; + } else if (setOctDigits.Contains(nextChar)) { + digitsLeft = 3; + escapeSetValid = &setOctDigits; + } + } + bool atEscapeEnd(int currChar) const { + return (digitsLeft <= 0) || !escapeSetValid->Contains(currChar); + } +}; + +std::string GetRestOfLine(LexAccessor &styler, int start, bool allowSpace) { std::string restOfLine; int i =0; char ch = styler.SafeGetCharAt(start, '\n'); @@ -100,40 +216,21 @@ static std::string GetRestOfLine(LexAccessor &styler, int start, bool allowSpace return restOfLine; }

-static bool IsStreamCommentStyle(int style) { +bool IsStreamCommentStyle(int style) { return style == SCE_C_COMMENT || style == SCE_C_COMMENTDOC || style == SCE_C_COMMENTDOCKEYWORD || style == SCE_C_COMMENTDOCKEYWORDERROR; }

-static std::vectorstd::string Tokenize(const std::string &s) { - // Break into space separated tokens - std::string word; - std::vectorstd::string tokens; - for (const char *cp = s.c_str(); *cp; cp++) { - if ((*cp == ' ') || (*cp == '\t')) { - if (!word.empty()) { - tokens.push_back(word); - word = ""; - } - } else { - word += *cp; - } - } - if (!word.empty()) { - tokens.push_back(word); - } - return tokens; -} - struct PPDefinition { int line; std::string key; std::string value; bool isUndef; - PPDefinition(int line_, const std::string &key_, const std::string &value_, bool isUndef_ = false) : - line(line_), key(key_), value(value_), isUndef(isUndef_) { + std::string arguments; + PPDefinition(int line_, const std::string &key_, const std::string &value_, bool isUndef_ = false, std::string arguments_="") : + line(line_), key(key_), value(value_), isUndef(isUndef_), arguments(arguments_) { } };

@@ -211,6 +308,8 @@ struct OptionsCPP { bool updatePreprocessor; bool triplequotedStrings; bool hashquotedStrings; + bool backQuotedStrings; + bool escapeSequence; bool fold; bool foldSyntaxBased; bool foldComment; @@ -229,6 +328,8 @@ struct OptionsCPP { updatePreprocessor = true; triplequotedStrings = false; hashquotedStrings = false; + backQuotedStrings = false; + escapeSequence = false; fold = false; foldSyntaxBased = true; foldComment = false; @@ -243,12 +344,13 @@ struct OptionsCPP { } };

-static const char *const cppWordLists[] = { +const char *const cppWordLists[] = { "Primary keywords and identifiers", "Secondary keywords and identifiers", "Documentation comment keywords", "Global classes and typedefs", "Preprocessor definitions", + "Task marker and error marker keywords", 0, };

@@ -274,6 +376,12 @@ struct OptionSetCPP : public OptionSet<OptionsCPP> { DefineProperty("lexer.cpp.hashquoted.strings", &OptionsCPP::hashquotedStrings, "Set to 1 to enable highlighting of hash-quoted strings.");

+ DefineProperty("lexer.cpp.backquoted.strings", &OptionsCPP::backQuotedStrings, + "Set to 1 to enable highlighting of back-quoted raw strings ."); + + DefineProperty("lexer.cpp.escape.sequence", &OptionsCPP::escapeSequence, + "Set to 1 to enable highlighting of escape sequences in strings"); + DefineProperty("fold", &OptionsCPP::fold);

DefineProperty("fold.cpp.syntax.based", &OptionsCPP::foldSyntaxBased, @@ -312,7 +420,9 @@ struct OptionSetCPP : public OptionSet<OptionsCPP> { } };

-static const char styleSubable[] = {SCE_C_IDENTIFIER, SCE_C_COMMENTDOCKEYWORD, 0}; +const char styleSubable[] = {SCE_C_IDENTIFIER, SCE_C_COMMENTDOCKEYWORD, 0}; + +}

class LexerCPP : public ILexerWithSubStyles { bool caseSensitive; @@ -321,6 +431,7 @@ class LexerCPP : public ILexerWithSubStyles { CharacterSet setArithmethicOp; CharacterSet setRelOp; CharacterSet setLogicalOp; + CharacterSet setWordStart; PPStates vlls; std::vector<PPDefinition> ppDefineHistory; WordList keywords; @@ -328,9 +439,26 @@ class LexerCPP : public ILexerWithSubStyles { WordList keywords3; WordList keywords4; WordList ppDefinitions; - std::map<std::string, std::string> preprocessorDefinitionsStart; + WordList markerList; + struct SymbolValue { + std::string value; + std::string arguments; + SymbolValue(const std::string &value_="", const std::string &arguments_="") : value(value_), arguments(arguments_) { + } + SymbolValue &operator = (const std::string &value_) { + value = value_; + arguments.clear(); + return *this; + } + bool IsMacro() const { + return !arguments.empty(); + } + }; + typedef std::map<std::string, SymbolValue> SymbolTable; + SymbolTable preprocessorDefinitionsStart; OptionsCPP options; OptionSetCPP osCPP; + EscapeSequence escapeSeq; SparseStatestd::string rawStringTerminators; enum { activeFlag = 0x40 }; enum { ssIdentifier, ssDocKeyword }; @@ -417,8 +545,9 @@ class LexerCPP : public ILexerWithSubStyles { static int MaskActive(int style) { return style & ~activeFlag; } - void EvaluateTokens(std::vectorstd::string &tokens); - bool EvaluateExpression(const std::string &expr, const std::map<std::string, std::string> &preprocessorDefinitions); + void EvaluateTokens(std::vectorstd::string &tokens, const SymbolTable &preprocessorDefinitions); + std::vectorstd::string Tokenize(const std::string &expr) const; + bool EvaluateExpression(const std::string &expr, const SymbolTable &preprocessorDefinitions); };

int SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val) { @@ -452,6 +581,9 @@ int SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) { case 4: wordListN = &ppDefinitions; break; + case 5: + wordListN = &markerList; + break; } int firstModification = -1; if (wordListN) { @@ -469,7 +601,16 @@ int SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) { if (cpEquals) { std::string name(cpDefinition, cpEquals - cpDefinition); std::string val(cpEquals+1); - preprocessorDefinitionsStart[name] = val; + size_t bracket = name.find('('); + size_t bracketEnd = name.find(')'); + if ((bracket != std::string::npos) && (bracketEnd != std::string::npos)) { + // Macro + std::string args = name.substr(bracket + 1, bracketEnd - bracket - 1); + name = name.substr(0, bracket); + preprocessorDefinitionsStart[name] = SymbolValue(val, args); + } else { + preprocessorDefinitionsStart[name] = val; + } } else { std::string name(cpDefinition); std::string val("1"); @@ -499,7 +640,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle,

CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\&<>#{}[]");

- CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true); + setWordStart = CharacterSet(CharacterSet::setAlpha, "_", 0x80, true);

CharacterSet setInvalidRawFirst(CharacterSet::setNone, " )\\t\v\f\n");

@@ -511,6 +652,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, int visibleChars = 0; bool lastWordWasUUID = false; int styleBeforeDCKeyword = SCE_C_DEFAULT; + int styleBeforeTaskMarker = SCE_C_DEFAULT; bool continuationLine = false; bool isIncludePreprocessor = false; bool isStringInPreprocessor = false; @@ -540,7 +682,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, } }

- StyleContext sc(startPos, length, initStyle, styler, static_cast<char>(0xff)); + StyleContext sc(startPos, length, initStyle, styler, static_cast<unsigned char>(0xff)); LinePPState preproc = vlls.ForLine(lineCurrent);

bool definitionsChanged = false; @@ -556,12 +698,12 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, definitionsChanged = true; }

- std::map<std::string, std::string> preprocessorDefinitions = preprocessorDefinitionsStart; + SymbolTable preprocessorDefinitions = preprocessorDefinitionsStart; for (std::vector<PPDefinition>::iterator itDef = ppDefineHistory.begin(); itDef != ppDefineHistory.end(); ++itDef) { if (itDef->isUndef) preprocessorDefinitions.erase(itDef->key); else - preprocessorDefinitions[itDef->key] = itDef->value; + preprocessorDefinitions[itDef->key] = SymbolValue(itDef->value, itDef->arguments); }

std::string rawStringTerminator = rawStringTerminators.ValueAt(lineCurrent-1); @@ -725,6 +867,9 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, if (sc.Match('*', '/')) { sc.Forward(); sc.ForwardSetState(SCE_C_DEFAULT|activitySet); + } else { + styleBeforeTaskMarker = SCE_C_COMMENT; + highlightTaskMarker(sc, styler, activitySet, markerList, caseSensitive); } break; case SCE_C_COMMENTDOC: @@ -742,6 +887,9 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, case SCE_C_COMMENTLINE: if (sc.atLineStart && !continuationLine) { sc.SetState(SCE_C_DEFAULT|activitySet); + } else { + styleBeforeTaskMarker = SCE_C_COMMENTLINE; + highlightTaskMarker(sc, styler, activitySet, markerList, caseSensitive); } break; case SCE_C_COMMENTLINEDOC: @@ -794,9 +942,11 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, isIncludePreprocessor = false; } } else if (sc.ch == '\') { - if (sc.chNext == '"' || sc.chNext == ''' || sc.chNext == '\') { - sc.Forward(); + if (options.escapeSequence) { + sc.SetState(SCE_C_ESCAPESEQUENCE|activitySet); + escapeSeq.resetEscapeState(sc.chNext); } + sc.Forward(); // Skip all characters after the backslash } else if (sc.ch == '"') { if (sc.chNext == '_') { sc.ChangeState(SCE_C_USERLITERAL|activitySet); @@ -805,6 +955,24 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, } } break; + case SCE_C_ESCAPESEQUENCE: + escapeSeq.digitsLeft--; + if (!escapeSeq.atEscapeEnd(sc.ch)) { + break; + } + if (sc.ch == '"') { + sc.SetState(SCE_C_STRING|activitySet); + sc.ForwardSetState(SCE_C_DEFAULT|activitySet); + } else if (sc.ch == '\') { + escapeSeq.resetEscapeState(sc.chNext); + sc.Forward(); + } else { + sc.SetState(SCE_C_STRING|activitySet); + if (sc.atLineEnd) { + sc.ChangeState(SCE_C_STRINGEOL|activitySet); + } + } + break; case SCE_C_HASHQUOTEDSTRING: if (sc.ch == '\') { if (sc.chNext == '"' || sc.chNext == ''' || sc.chNext == '\') { @@ -880,6 +1048,12 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, if (sc.atLineEnd || sc.ch == ')') { sc.SetState(SCE_C_DEFAULT|activitySet); } + break; + case SCE_C_TASKMARKER: + if (isoperator(sc.ch) || IsASpace(sc.ch)) { + sc.SetState(styleBeforeTaskMarker|activitySet); + styleBeforeTaskMarker = SCE_C_DEFAULT; + } }

if (sc.atLineEnd && !atLineEndBeforeSwitch) { @@ -900,6 +1074,10 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, } else if (options.hashquotedStrings && sc.Match('#', '"')) { sc.SetState(SCE_C_HASHQUOTEDSTRING|activitySet); sc.Forward(); + } else if (options.backQuotedStrings && sc.Match('`')) { + sc.SetState(SCE_C_STRINGRAW|activitySet); + rawStringTerminator = "`"; + sc.Forward(); } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) { if (lastWordWasUUID) { sc.SetState(SCE_C_UUID|activitySet); @@ -1018,19 +1196,35 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, } else if (sc.Match("define")) { if (options.updatePreprocessor && !preproc.IsInactive()) { std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true); - if (restOfLine.find(")") == std::string::npos) { // Don't handle macros with arguments - std::vectorstd::string tokens = Tokenize(restOfLine); - std::string key; - std::string value("1"); - if (tokens.size() >= 1) { - key = tokens[0]; - if (tokens.size() >= 2) { - value = tokens[1]; - } - preprocessorDefinitions[key] = value; - ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value)); - definitionsChanged = true; - } + size_t startName = 0; + while ((startName < restOfLine.length()) && IsSpaceOrTab(restOfLine[startName])) + startName++; + size_t endName = startName; + while ((endName < restOfLine.length()) && setWord.Contains(static_cast<unsigned char>(restOfLine[endName]))) + endName++; + std::string key = restOfLine.substr(startName, endName-startName); + if (restOfLine[endName] == '(') { + // Macro + size_t endArgs = endName; + while ((endArgs < restOfLine.length()) && (restOfLine[endArgs] != ')')) + endArgs++; + std::string args = restOfLine.substr(endName + 1, endArgs - endName - 1); + size_t startValue = endArgs+1; + while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue])) + startValue++; + std::string value = restOfLine.substr(startValue); + preprocessorDefinitions[key] = SymbolValue(value, args); + ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value, false, args)); + definitionsChanged = true; + } else { + // Value + size_t startValue = endName; + while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue])) + startValue++; + std::string value = restOfLine.substr(startValue); + preprocessorDefinitions[key] = value; + ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value)); + definitionsChanged = true; } } } else if (sc.Match("undef")) { @@ -1180,19 +1374,36 @@ void SCI_METHOD LexerCPP::Fold(unsigned int startPos, int length, int initStyle, } }

-void LexerCPP::EvaluateTokens(std::vectorstd::string &tokens) { +void LexerCPP::EvaluateTokens(std::vectorstd::string &tokens, const SymbolTable &preprocessorDefinitions) {

- // Evaluate defined() statements to either 0 or 1 - for (size_t i=0; (i+2)<tokens.size();) { - if ((tokens[i] == "defined") && (tokens[i+1] == "(")) { + // Remove whitespace tokens + tokens.erase(std::remove_if(tokens.begin(), tokens.end(), OnlySpaceOrTab), tokens.end()); + + // Evaluate defined statements to either 0 or 1 + for (size_t i=0; (i+1)<tokens.size();) { + if (tokens[i] == "defined") { const char *val = "0"; - if (tokens[i+2] == ")") { - // defined() - tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 3); - } else if (((i+3)<tokens.size()) && (tokens[i+3] == ")")) { - // defined(<int>) - tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 4); - val = "1"; + if (tokens[i+1] == "(") { + if (((i + 2)<tokens.size()) && (tokens[i + 2] == ")")) { + // defined() + tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 3); + } else if (((i+3)<tokens.size()) && (tokens[i+3] == ")")) { + // defined(<identifier>) + SymbolTable::const_iterator it = preprocessorDefinitions.find(tokens[i+2]); + if (it != preprocessorDefinitions.end()) { + val = "1"; + } + tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 4); + } else { + // Spurious '(' so erase as more likely to result in false + tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 2); + } + } else { + // defined <identifier> + SymbolTable::const_iterator it = preprocessorDefinitions.find(tokens[i+1]); + if (it != preprocessorDefinitions.end()) { + val = "1"; + } } tokens[i] = val; } else { @@ -1200,21 +1411,82 @@ void LexerCPP::EvaluateTokens(std::vectorstd::string &tokens) { } }

+ // Evaluate identifiers + const size_t maxIterations = 100; + size_t iterations = 0; // Limit number of iterations in case there is a recursive macro. + for (size_t i = 0; (i<tokens.size()) && (iterations < maxIterations);) { + iterations++; + if (setWordStart.Contains(static_cast<unsigned char>(tokens[i][0]))) { + SymbolTable::const_iterator it = preprocessorDefinitions.find(tokens[i]); + if (it != preprocessorDefinitions.end()) { + // Tokenize value + std::vectorstd::string macroTokens = Tokenize(it->second.value); + if (it->second.IsMacro()) { + if ((i + 1 < tokens.size()) && (tokens.at(i + 1) == "(")) { + // Create map of argument name to value + std::vectorstd::string argumentNames = StringSplit(it->second.arguments, ','); + std::map<std::string, std::string> arguments; + size_t arg = 0; + size_t tok = i+2; + while ((tok < tokens.size()) && (arg < argumentNames.size()) && (tokens.at(tok) != ")")) { + if (tokens.at(tok) != ",") { + arguments[argumentNames.at(arg)] = tokens.at(tok); + arg++; + } + tok++; + } + + // Remove invocation + tokens.erase(tokens.begin() + i, tokens.begin() + tok + 1); + + // Substitute values into macro + macroTokens.erase(std::remove_if(macroTokens.begin(), macroTokens.end(), OnlySpaceOrTab), macroTokens.end()); + + for (size_t iMacro = 0; iMacro < macroTokens.size();) { + if (setWordStart.Contains(static_cast<unsigned char>(macroTokens[iMacro][0]))) { + std::map<std::string, std::string>::const_iterator itFind = arguments.find(macroTokens[iMacro]); + if (itFind != arguments.end()) { + // TODO: Possible that value will be expression so should insert tokenized form + macroTokens[iMacro] = itFind->second; + } + } + iMacro++; + } + + // Insert results back into tokens + tokens.insert(tokens.begin() + i, macroTokens.begin(), macroTokens.end()); + + } else { + i++; + } + } else { + // Remove invocation + tokens.erase(tokens.begin() + i); + // Insert results back into tokens + tokens.insert(tokens.begin() + i, macroTokens.begin(), macroTokens.end()); + } + } else { + // Identifier not found + tokens.erase(tokens.begin() + i); + } + } else { + i++; + } + } + // Find bracketed subexpressions and recurse on them - std::vectorstd::string::iterator itBracket = std::find(tokens.begin(), tokens.end(), "("); - std::vectorstd::string::iterator itEndBracket = std::find(tokens.begin(), tokens.end(), ")"); - while ((itBracket != tokens.end()) && (itEndBracket != tokens.end()) && (itEndBracket > itBracket)) { - std::vectorstd::string inBracket(itBracket + 1, itEndBracket); - EvaluateTokens(inBracket); + BracketPair bracketPair = FindBracketPair(tokens); + while (bracketPair.itBracket != tokens.end()) { + std::vectorstd::string inBracket(bracketPair.itBracket + 1, bracketPair.itEndBracket); + EvaluateTokens(inBracket, preprocessorDefinitions);

// The insertion is done before the removal because there were failures with the opposite approach - tokens.insert(itBracket, inBracket.begin(), inBracket.end()); - itBracket = std::find(tokens.begin(), tokens.end(), "("); - itEndBracket = std::find(tokens.begin(), tokens.end(), ")"); - tokens.erase(itBracket, itEndBracket + 1); + tokens.insert(bracketPair.itBracket, inBracket.begin(), inBracket.end());

- itBracket = std::find(tokens.begin(), tokens.end(), "("); - itEndBracket = std::find(tokens.begin(), tokens.end(), ")"); + bracketPair = FindBracketPair(tokens); + tokens.erase(bracketPair.itBracket, bracketPair.itEndBracket + 1); + + bracketPair = FindBracketPair(tokens); }

// Evaluate logical negations @@ -1283,45 +1555,51 @@ void LexerCPP::EvaluateTokens(std::vectorstd::string &tokens) { } }

-bool LexerCPP::EvaluateExpression(const std::string &expr, const std::map<std::string, std::string> &preprocessorDefinitions) { - // Break into tokens, replacing with definitions - std::string word; +std::vectorstd::string LexerCPP::Tokenize(const std::string &expr) const { + // Break into tokens std::vectorstd::string tokens; const char *cp = expr.c_str(); - for (;;) { + while (*cp) { + std::string word; if (setWord.Contains(static_cast<unsigned char>(*cp))) { - word += *cp; - } else { - std::map<std::string, std::string>::const_iterator it = preprocessorDefinitions.find(word); - if (it != preprocessorDefinitions.end()) { - tokens.push_back(it->second); - } else if (!word.empty() && ((word[0] >= '0' && word[0] <= '9') || (word == "defined"))) { - tokens.push_back(word); + // Identifiers and numbers + while (setWord.Contains(static_cast<unsigned char>(*cp))) { + word += *cp; + cp++; } - word = ""; - if (!*cp) { - break; + } else if (IsSpaceOrTab(*cp)) { + while (IsSpaceOrTab(*cp)) { + word += *cp; + cp++; } - if ((*cp != ' ') && (*cp != '\t')) { - std::string op(cp, 1); - if (setRelOp.Contains(static_cast<unsigned char>(*cp))) { - if (setRelOp.Contains(static_cast<unsigned char>(cp[1]))) { - op += cp[1]; - cp++; - } - } else if (setLogicalOp.Contains(static_cast<unsigned char>(*cp))) { - if (setLogicalOp.Contains(static_cast<unsigned char>(cp[1]))) { - op += cp[1]; - cp++; - } - } - tokens.push_back(op); + } else if (setRelOp.Contains(static_cast<unsigned char>(*cp))) { + word += *cp; + cp++; + if (setRelOp.Contains(static_cast<unsigned char>(*cp))) { + word += *cp; + cp++; + } + } else if (setLogicalOp.Contains(static_cast<unsigned char>(*cp))) { + word += *cp; + cp++; + if (setLogicalOp.Contains(static_cast<unsigned char>(*cp))) { + word += *cp; + cp++; } + } else { + // Should handle strings, characters, and comments here + word += *cp; + cp++; } - cp++; + tokens.push_back(word); } + return tokens; +} + +bool LexerCPP::EvaluateExpression(const std::string &expr, const SymbolTable &preprocessorDefinitions) { + std::vectorstd::string tokens = Tokenize(expr);

- EvaluateTokens(tokens); + EvaluateTokens(tokens, preprocessorDefinitions);

// "0" or "" -> false else true bool isFalse = tokens.empty() ||

Modified: scintilla/lexers/LexHTML.cxx 8 lines changed, 4 insertions(+), 4 deletions(-) =================================================================== @@ -577,7 +577,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty WordList &keywords6 = *keywordlists[5]; // SGML (DTD) keywords

// Lexer for HTML requires more lexical states (8 bits worth) than most lexers - styler.StartAt(startPos, static_cast<char>(STYLE_MAX)); + styler.StartAt(startPos, static_cast<unsigned char>(STYLE_MAX)); char prevWord[200]; prevWord[0] = '\0'; char phpStringDelimiter[200]; // PHP is not limited in length, we are @@ -609,7 +609,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty if (startPos == 0) state = SCE_H_DEFAULT; } - styler.StartAt(startPos, static_cast<char>(STYLE_MAX)); + styler.StartAt(startPos, static_cast<unsigned char>(STYLE_MAX));

int lineCurrent = styler.GetLine(startPos); int lineState; @@ -811,8 +811,8 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty } styler.SetLineState(lineCurrent, ((inScriptType & 0x03) << 0) | - ((tagOpened & 0x01) << 2) | - ((tagClosing & 0x01) << 3) | + ((tagOpened ? 1 : 0) << 2) | + ((tagClosing ? 1 : 0) << 3) | ((aspScript & 0x0F) << 4) | ((clientScript & 0x0F) << 8) | ((beforePreProc & 0xFF) << 12));

Modified: scintilla/lexers/LexLua.cxx 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -141,7 +141,7 @@ static void ColouriseLuaDoc( char s[100]; while (setWord.Contains(c = sc.GetRelative(ln))) { // get potential label if (i < 90) - s[i++] = c; + s[i++] = static_cast<char>(c); ln++; } s[i] = '\0'; int lbl = ln;

Modified: scintilla/lexlib/LexerModule.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -72,7 +72,7 @@ inline int Maximum(int a, int b) {

// Shut up annoying Visual C++ warnings: #ifdef _MSC_VER -#pragma warning(disable: 4244 4309 4514 4710) +#pragma warning(disable: 4244 4309) #endif

#ifdef SCI_NAMESPACE

Modified: scintilla/lexlib/PropSetSimple.cxx 5 lines changed, 0 insertions(+), 5 deletions(-) =================================================================== @@ -11,11 +11,6 @@ #include <string.h> #include <stdio.h>

-#ifdef _MSC_VER -// Visual C++ doesn't like unreachable code in its own headers. -#pragma warning(disable: 4018 4100 4245 4511 4512 4663 4702) -#endif - #include <string> #include <map>

Modified: scintilla/scintilla_changes.patch 3 lines changed, 2 insertions(+), 1 deletions(-) =================================================================== @@ -31,7 +31,7 @@ diff --git b/scintilla/src/Catalogue.cxx a/scintilla/src/Catalogue.cxx index 41d5d54..70ce3bc 100644 --- scintilla/src/Catalogue.cxx +++ scintilla/src/Catalogue.cxx -@@ -76,114 +76,48 @@ int Scintilla_LinkLexers() { +@@ -76,115 +76,48 @@ int Scintilla_LinkLexers() {

//++Autogenerated -- run scripts/LexGen.py to regenerate //**(\tLINK_LEXER(*);\n) @@ -65,6 +65,7 @@ index 41d5d54..70ce3bc 100644 LINK_LEXER(lmD); LINK_LEXER(lmDiff); - LINK_LEXER(lmDMAP); +- LINK_LEXER(lmDMIS); - LINK_LEXER(lmECL); - LINK_LEXER(lmEiffel); - LINK_LEXER(lmEiffelkw);

Modified: scintilla/src/CallTip.cxx 63 lines changed, 32 insertions(+), 31 deletions(-) =================================================================== @@ -109,13 +109,15 @@ void CallTip::DrawChunk(Surface *surface, int &x, const char *s, int endSeg = ends[seg]; if (endSeg > startSeg) { if (IsArrowCharacter(s[startSeg])) { + xEnd = x + widthArrow; bool upArrow = s[startSeg] == '\001'; - rcClient.left = x; - rcClient.right = rcClient.left + widthArrow; + rcClient.left = static_cast<XYPOSITION>(x); + rcClient.right = static_cast<XYPOSITION>(xEnd); if (draw) { const int halfWidth = widthArrow / 2 - 3; - const int centreX = rcClient.left + widthArrow / 2 - 1; - const int centreY = (rcClient.top + rcClient.bottom) / 2; + const int quarterWidth = halfWidth / 2; + const int centreX = x + widthArrow / 2 - 1; + const int centreY = static_cast<int>(rcClient.top + rcClient.bottom) / 2; surface->FillRectangle(rcClient, colourBG); PRectangle rcClientInner(rcClient.left + 1, rcClient.top + 1, rcClient.right - 2, rcClient.bottom - 1); @@ -123,21 +125,20 @@ void CallTip::DrawChunk(Surface *surface, int &x, const char *s,

if (upArrow) { // Up arrow Point pts[] = { - Point(centreX - halfWidth, centreY + halfWidth / 2), - Point(centreX + halfWidth, centreY + halfWidth / 2), - Point(centreX, centreY - halfWidth + halfWidth / 2), + Point::FromInts(centreX - halfWidth, centreY + quarterWidth), + Point::FromInts(centreX + halfWidth, centreY + quarterWidth), + Point::FromInts(centreX, centreY - halfWidth + quarterWidth), }; surface->Polygon(pts, ELEMENTS(pts), colourBG, colourBG); } else { // Down arrow Point pts[] = { - Point(centreX - halfWidth, centreY - halfWidth / 2), - Point(centreX + halfWidth, centreY - halfWidth / 2), - Point(centreX, centreY + halfWidth - halfWidth / 2), + Point::FromInts(centreX - halfWidth, centreY - quarterWidth), + Point::FromInts(centreX + halfWidth, centreY - quarterWidth), + Point::FromInts(centreX, centreY + halfWidth - quarterWidth), }; surface->Polygon(pts, ELEMENTS(pts), colourBG, colourBG); } } - xEnd = rcClient.right; offsetMain = xEnd; if (upArrow) { rectUp = rcClient; @@ -147,11 +148,11 @@ void CallTip::DrawChunk(Surface *surface, int &x, const char *s, } else if (IsTabCharacter(s[startSeg])) { xEnd = NextTabPos(x); } else { - xEnd = x + surface->WidthText(font, s + startSeg, endSeg - startSeg); + xEnd = x + RoundXYPosition(surface->WidthText(font, s + startSeg, endSeg - startSeg)); if (draw) { - rcClient.left = x; - rcClient.right = xEnd; - surface->DrawTextTransparent(rcClient, font, ytext, + rcClient.left = static_cast<XYPOSITION>(x); + rcClient.right = static_cast<XYPOSITION>(xEnd); + surface->DrawTextTransparent(rcClient, font, static_cast<XYPOSITION>(ytext), s+startSeg, endSeg - startSeg, highlight ? colourSel : colourUnSel); } @@ -164,16 +165,16 @@ void CallTip::DrawChunk(Surface *surface, int &x, const char *s,

int CallTip::PaintContents(Surface *surfaceWindow, bool draw) { PRectangle rcClientPos = wCallTip.GetClientPosition(); - PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left, + PRectangle rcClientSize(0.0f, 0.0f, rcClientPos.right - rcClientPos.left, rcClientPos.bottom - rcClientPos.top); - PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1); + PRectangle rcClient(1.0f, 1.0f, rcClientSize.right - 1, rcClientSize.bottom - 1);

// To make a nice small call tip window, it is only sized to fit most normal characters without accents - int ascent = surfaceWindow->Ascent(font) - surfaceWindow->InternalLeading(font); + int ascent = RoundXYPosition(surfaceWindow->Ascent(font) - surfaceWindow->InternalLeading(font));

// For each line... // Draw the definition in three parts: before highlight, highlighted, after highlight - int ytext = rcClient.top + ascent + 1; + int ytext = static_cast<int>(rcClient.top) + ascent + 1; rcClient.bottom = ytext + surfaceWindow->Descent(font) + 1; const char *chunkVal = val.c_str(); bool moreChunks = true; @@ -185,8 +186,8 @@ int CallTip::PaintContents(Surface *surfaceWindow, bool draw) { chunkEnd = chunkVal + strlen(chunkVal); moreChunks = false; } - int chunkOffset = chunkVal - val.c_str(); - int chunkLength = chunkEnd - chunkVal; + int chunkOffset = static_cast<int>(chunkVal - val.c_str()); + int chunkLength = static_cast<int>(chunkEnd - chunkVal); int chunkEndOffset = chunkOffset + chunkLength; int thisStartHighlight = Platform::Maximum(startHighlight, chunkOffset); thisStartHighlight = Platform::Minimum(thisStartHighlight, chunkEndOffset); @@ -194,7 +195,7 @@ int CallTip::PaintContents(Surface *surfaceWindow, bool draw) { int thisEndHighlight = Platform::Maximum(endHighlight, chunkOffset); thisEndHighlight = Platform::Minimum(thisEndHighlight, chunkEndOffset); thisEndHighlight -= chunkOffset; - rcClient.top = ytext - ascent - 1; + rcClient.top = static_cast<XYPOSITION>(ytext - ascent - 1);

int x = insetX; // start each line at this inset

@@ -217,9 +218,9 @@ void CallTip::PaintCT(Surface *surfaceWindow) { if (val.empty()) return; PRectangle rcClientPos = wCallTip.GetClientPosition(); - PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left, + PRectangle rcClientSize(0.0f, 0.0f, rcClientPos.right - rcClientPos.left, rcClientPos.bottom - rcClientPos.top); - PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1); + PRectangle rcClient(1.0f, 1.0f, rcClientSize.right - 1, rcClientSize.bottom - 1);

surfaceWindow->FillRectangle(rcClient, colourBG);

@@ -229,13 +230,13 @@ void CallTip::PaintCT(Surface *surfaceWindow) { #ifndef __APPLE__ // OSX doesn't put borders on "help tags" // Draw a raised border around the edges of the window - surfaceWindow->MoveTo(0, rcClientSize.bottom - 1); + surfaceWindow->MoveTo(0, static_cast<int>(rcClientSize.bottom) - 1); surfaceWindow->PenColour(colourShade); - surfaceWindow->LineTo(rcClientSize.right - 1, rcClientSize.bottom - 1); - surfaceWindow->LineTo(rcClientSize.right - 1, 0); + surfaceWindow->LineTo(static_cast<int>(rcClientSize.right) - 1, static_cast<int>(rcClientSize.bottom) - 1); + surfaceWindow->LineTo(static_cast<int>(rcClientSize.right) - 1, 0); surfaceWindow->PenColour(colourLight); surfaceWindow->LineTo(0, 0); - surfaceWindow->LineTo(0, rcClientSize.bottom - 1); + surfaceWindow->LineTo(0, static_cast<int>(rcClientSize.bottom) - 1); #endif }

@@ -264,7 +265,7 @@ PRectangle CallTip::CallTipStart(int pos, Point pt, int textHeight, const char * endHighlight = 0; inCallTipMode = true; posStartCallTip = pos; - int deviceHeight = surfaceMeasure->DeviceHeightFont(size); + XYPOSITION deviceHeight = static_cast<XYPOSITION>(surfaceMeasure->DeviceHeightFont(size)); FontParameters fp(faceName, deviceHeight / SC_FONT_SIZE_MULTIPLIER, SC_WEIGHT_NORMAL, false, 0, technology, characterSet); font.Create(fp); // Look for multiple lines in the text @@ -280,12 +281,12 @@ PRectangle CallTip::CallTipStart(int pos, Point pt, int textHeight, const char * look = newline + 1; numLines++; } - lineHeight = surfaceMeasure->Height(font); + lineHeight = RoundXYPosition(surfaceMeasure->Height(font));

// The returned // rectangle is aligned to the right edge of the last arrow encountered in // the tip text, else to the tip text left edge. - int height = lineHeight * numLines - surfaceMeasure->InternalLeading(font) + borderHeight * 2; + int height = lineHeight * numLines - static_cast<int>(surfaceMeasure->InternalLeading(font)) + borderHeight * 2; delete surfaceMeasure; if (above) { return PRectangle(pt.x - offsetMain, pt.y - verticalOffset - height, pt.x + width - offsetMain, pt.y - verticalOffset);

Modified: scintilla/src/CharClassify.cxx 5 lines changed, 0 insertions(+), 5 deletions(-) =================================================================== @@ -14,11 +14,6 @@ using namespace Scintilla; #endif

-// Shut up annoying Visual C++ warnings: -#ifdef _MSC_VER -#pragma warning(disable: 4514) -#endif - CharClassify::CharClassify() { SetDefaultCharClasses(true); }

Modified: scintilla/src/ContractionState.cxx 4 lines changed, 4 insertions(+), 0 deletions(-) =================================================================== @@ -76,6 +76,10 @@ int ContractionState::DisplayFromDoc(int lineDoc) const { } }

+int ContractionState::DisplayLastFromDoc(int lineDoc) const { + return DisplayFromDoc(lineDoc) + GetHeight(lineDoc) - 1; +} + int ContractionState::DocFromDisplay(int lineDisplay) const { if (OneToOne()) { return lineDisplay;

Modified: scintilla/src/ContractionState.h 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -39,6 +39,7 @@ class ContractionState { int LinesInDoc() const; int LinesDisplayed() const; int DisplayFromDoc(int lineDoc) const; + int DisplayLastFromDoc(int lineDoc) const; int DocFromDisplay(int lineDisplay) const;

void InsertLine(int lineDoc);

Modified: scintilla/src/Document.cxx 113 lines changed, 60 insertions(+), 53 deletions(-) =================================================================== @@ -98,6 +98,7 @@ Document::Document() { enteredModification = 0; enteredStyling = 0; enteredReadOnlyCount = 0; + insertionSet = false; tabInChars = 8; indentInChars = 0; actualIndentInChars = 8; @@ -919,37 +920,56 @@ bool Document::DeleteChars(int pos, int len) { /** * Insert a string with a length. */ -bool Document::InsertString(int position, const char *s, int insertLength) { +int Document::InsertString(int position, const char *s, int insertLength) { if (insertLength <= 0) { - return false; + return 0; + } + CheckReadOnly(); // Application may change read only state here + if (cb.IsReadOnly()) { + return 0; } - CheckReadOnly(); if (enteredModification != 0) { - return false; - } else { - enteredModification++; - if (!cb.IsReadOnly()) { - NotifyModified( - DocModification( - SC_MOD_BEFOREINSERT | SC_PERFORMED_USER, - position, insertLength, - 0, s)); - int prevLinesTotal = LinesTotal(); - bool startSavePoint = cb.IsSavePoint(); - bool startSequence = false; - const char *text = cb.InsertString(position, s, insertLength, startSequence); - if (startSavePoint && cb.IsCollectingUndo()) - NotifySavePoint(!startSavePoint); - ModifiedAt(position); - NotifyModified( - DocModification( - SC_MOD_INSERTTEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0), - position, insertLength, - LinesTotal() - prevLinesTotal, text)); - } - enteredModification--; + return 0; } - return !cb.IsReadOnly(); + enteredModification++; + insertionSet = false; + insertion.clear(); + NotifyModified( + DocModification( + SC_MOD_INSERTCHECK, + position, insertLength, + 0, s)); + if (insertionSet) { + s = insertion.c_str(); + insertLength = static_cast<int>(insertion.length()); + } + NotifyModified( + DocModification( + SC_MOD_BEFOREINSERT | SC_PERFORMED_USER, + position, insertLength, + 0, s)); + int prevLinesTotal = LinesTotal(); + bool startSavePoint = cb.IsSavePoint(); + bool startSequence = false; + const char *text = cb.InsertString(position, s, insertLength, startSequence); + if (startSavePoint && cb.IsCollectingUndo()) + NotifySavePoint(!startSavePoint); + ModifiedAt(position); + NotifyModified( + DocModification( + SC_MOD_INSERTTEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0), + position, insertLength, + LinesTotal() - prevLinesTotal, text)); + if (insertionSet) { // Free memory as could be large + std::string().swap(insertion); + } + enteredModification--; + return insertLength; +} + +void Document::ChangeInsertion(const char *s, int length) { + insertionSet = true; + insertion.assign(s, length); }

int SCI_METHOD Document::AddData(char *data, int length) { @@ -1113,22 +1133,6 @@ int Document::Redo() { return newPos; }

-/** - * Insert a single character. - */ -bool Document::InsertChar(int pos, char ch) { - char chs[1]; - chs[0] = ch; - return InsertString(pos, chs, 1); -} - -/** - * Insert a null terminated string. - */ -bool Document::InsertCString(int position, const char *s) { - return InsertString(position, s, static_cast<int>(s ? strlen(s) : 0)); -} - void Document::DelChar(int pos) { DeleteChars(pos, LenChar(pos)); } @@ -1183,7 +1187,7 @@ int SCI_METHOD Document::GetLineIndentation(int line) { return indent; }

-void Document::SetLineIndentation(int line, int indent) { +int Document::SetLineIndentation(int line, int indent) { int indentOfLine = GetLineIndentation(line); if (indent < 0) indent = 0; @@ -1193,7 +1197,10 @@ void Document::SetLineIndentation(int line, int indent) { int indentPos = GetLineIndentPosition(line); UndoGroup ug(this); DeleteChars(thisLineStart, indentPos - thisLineStart); - InsertCString(thisLineStart, linebuf.c_str()); + return thisLineStart + InsertString(thisLineStart, linebuf.c_str(), + static_cast<int>(linebuf.length())); + } else { + return GetLineIndentPosition(line); } }

@@ -1325,21 +1332,21 @@ void Document::ConvertLineEnds(int eolModeSet) { } else { // CR if (eolModeSet == SC_EOL_CRLF) { - InsertString(pos + 1, "\n", 1); // Insert LF - pos++; + pos += InsertString(pos + 1, "\n", 1); // Insert LF } else if (eolModeSet == SC_EOL_LF) { - InsertString(pos, "\n", 1); // Insert LF - DeleteChars(pos + 1, 1); // Delete CR + pos += InsertString(pos, "\n", 1); // Insert LF + DeleteChars(pos, 1); // Delete CR + pos--; } } } else if (cb.CharAt(pos) == '\n') { // LF if (eolModeSet == SC_EOL_CRLF) { - InsertString(pos, "\r", 1); // Insert CR - pos++; + pos += InsertString(pos, "\r", 1); // Insert CR } else if (eolModeSet == SC_EOL_CR) { - InsertString(pos, "\r", 1); // Insert CR - DeleteChars(pos + 1, 1); // Delete LF + pos += InsertString(pos, "\r", 1); // Insert CR + DeleteChars(pos, 1); // Delete LF + pos--; } } }

Modified: scintilla/src/Document.h 20 lines changed, 15 insertions(+), 5 deletions(-) =================================================================== @@ -43,6 +43,14 @@ class Range { return (start != invalidPosition) && (end != invalidPosition); }

+ Position First() const { + return (start <= end) ? start : end; + } + + Position Last() const { + return (start > end) ? start : end; + } + // Is the position within the range? bool Contains(Position pos) const { if (start < end) { @@ -205,6 +213,9 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader { int enteredStyling; int enteredReadOnlyCount;

+ bool insertionSet; + std::string insertion; + std::vector<WatcherWithUserData> watchers;

// ldSize is not real data - it is for dimensions and loops @@ -274,7 +285,8 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader { void ModifiedAt(int pos); void CheckReadOnly(); bool DeleteChars(int pos, int len); - bool InsertString(int position, const char *s, int insertLength); + int InsertString(int position, const char *s, int insertLength); + void ChangeInsertion(const char *s, int length); int SCI_METHOD AddData(char *data, int length); void * SCI_METHOD ConvertToDocument(); int Undo(); @@ -296,7 +308,7 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader { int GapPosition() const { return cb.GapPosition(); }

int SCI_METHOD GetLineIndentation(int line); - void SetLineIndentation(int line, int indent); + int SetLineIndentation(int line, int indent); int GetLineIndentPosition(int line) const; int GetColumn(int position); int CountCharacters(int startPos, int endPos); @@ -307,8 +319,6 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader { void SetReadOnly(bool set) { cb.SetReadOnly(set); } bool IsReadOnly() const { return cb.IsReadOnly(); }

- bool InsertChar(int pos, char ch); - bool InsertCString(int position, const char *s); void DelChar(int pos); void DelCharBack(int pos);

@@ -390,7 +400,7 @@ class Document : PerLine, public IDocumentWithLineEnd, public ILoader { void AnnotationSetStyles(int line, const unsigned char *styles); int AnnotationLines(int line) const; void AnnotationClearAll(); - + bool AddWatcher(DocWatcher *watcher, void *userData); bool RemoveWatcher(DocWatcher *watcher, void *userData);

Modified: scintilla/src/Editor.cxx 1121 lines changed, 595 insertions(+), 526 deletions(-) =================================================================== No diff available, check online

Modified: scintilla/src/Editor.h 11 lines changed, 7 insertions(+), 4 deletions(-) =================================================================== @@ -356,12 +356,12 @@ class Editor : public DocWatcher { int LineFromLocation(Point pt) const; void SetTopLine(int topLineNew);

- bool AbandonPaint(); + virtual bool AbandonPaint(); virtual void RedrawRect(PRectangle rc); virtual void DiscardOverdraw(); virtual void Redraw(); void RedrawSelMargin(int line=-1, bool allAfter=false); - PRectangle RectangleFromRange(int start, int end); + PRectangle RectangleFromRange(Range r); void InvalidateRange(int start, int end);

bool UserVirtualSpace() const { @@ -420,6 +420,7 @@ class Editor : public DocWatcher { void ScrollRange(SelectionRange range); void ShowCaretAtCurrentPosition(); void DropCaret(); + void CaretSetPeriod(int period); void InvalidateCaret(); virtual void UpdateSystemCaret();

@@ -472,8 +473,10 @@ class Editor : public DocWatcher { int InsertSpace(int position, unsigned int spaces); void AddChar(char ch); virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false); - void InsertPaste(SelectionPosition selStart, const char *text, int len); - void ClearSelection(bool retainMultipleSelections=false); + void InsertPaste(const char *text, int len); + enum PasteShape { pasteStream=0, pasteRectangular = 1, pasteLine = 2 }; + void InsertPasteShape(const char *text, int len, PasteShape shape); + void ClearSelection(bool retainMultipleSelections = false); void ClearAll(); void ClearDocumentStyle(); void Cut();

Modified: scintilla/src/Indicator.cxx 72 lines changed, 36 insertions(+), 36 deletions(-) =================================================================== @@ -20,17 +20,17 @@ using namespace Scintilla;

static PRectangle PixelGridAlign(const PRectangle &rc) { // Move left and right side to nearest pixel to avoid blurry visuals - return PRectangle(int(rc.left + 0.5), rc.top, int(rc.right + 0.5), rc.bottom); + return PRectangle::FromInts(int(rc.left + 0.5), int(rc.top), int(rc.right + 0.5), int(rc.bottom)); }

void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine) { surface->PenColour(fore); - int ymid = (rc.bottom + rc.top) / 2; + int ymid = static_cast<int>(rc.bottom + rc.top) / 2; if (style == INDIC_SQUIGGLE) { int x = int(rc.left+0.5); int xLast = int(rc.right+0.5); int y = 0; - surface->MoveTo(x, rc.top + y); + surface->MoveTo(x, static_cast<int>(rc.top) + y); while (x < xLast) { if ((x + 2) > xLast) { if (xLast > x) @@ -40,12 +40,12 @@ void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &r x += 2; y = 2 - y; } - surface->LineTo(x, rc.top + y); + surface->LineTo(x, static_cast<int>(rc.top) + y); } } else if (style == INDIC_SQUIGGLEPIXMAP) { PRectangle rcSquiggle = PixelGridAlign(rc);

- int width = Platform::Minimum(4000, rcSquiggle.Width()); + int width = Platform::Minimum(4000, static_cast<int>(rcSquiggle.Width())); RGBAImage image(width, 3, 1.0, 0); enum { alphaFull = 0xff, alphaSide = 0x2f, alphaSide2=0x5f }; for (int x = 0; x < width; x++) { @@ -62,19 +62,19 @@ void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &r } surface->DrawRGBAImage(rcSquiggle, image.GetWidth(), image.GetHeight(), image.Pixels()); } else if (style == INDIC_SQUIGGLELOW) { - surface->MoveTo(rc.left, rc.top); - int x = rc.left + 3; + surface->MoveTo(static_cast<int>(rc.left), static_cast<int>(rc.top)); + int x = static_cast<int>(rc.left) + 3; int y = 0; while (x < rc.right) { - surface->LineTo(x-1, rc.top + y); + surface->LineTo(x - 1, static_cast<int>(rc.top) + y); y = 1 - y; - surface->LineTo(x, rc.top + y); + surface->LineTo(x, static_cast<int>(rc.top) + y); x += 3; } - surface->LineTo(rc.right, rc.top + y); // Finish the line + surface->LineTo(static_cast<int>(rc.right), static_cast<int>(rc.top) + y); // Finish the line } else if (style == INDIC_TT) { - surface->MoveTo(rc.left, ymid); - int x = rc.left + 5; + surface->MoveTo(static_cast<int>(rc.left), ymid); + int x = static_cast<int>(rc.left) + 5; while (x < rc.right) { surface->LineTo(x, ymid); surface->MoveTo(x-3, ymid); @@ -83,35 +83,35 @@ void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &r surface->MoveTo(x, ymid); x += 5; } - surface->LineTo(rc.right, ymid); // Finish the line + surface->LineTo(static_cast<int>(rc.right), ymid); // Finish the line if (x - 3 <= rc.right) { surface->MoveTo(x-3, ymid); surface->LineTo(x-3, ymid+2); } } else if (style == INDIC_DIAGONAL) { - int x = rc.left; + int x = static_cast<int>(rc.left); while (x < rc.right) { - surface->MoveTo(x, rc.top+2); + surface->MoveTo(x, static_cast<int>(rc.top) + 2); int endX = x+3; - int endY = rc.top - 1; + int endY = static_cast<int>(rc.top) - 1; if (endX > rc.right) { - endY += endX - rc.right; - endX = rc.right; + endY += endX - static_cast<int>(rc.right); + endX = static_cast<int>(rc.right); } surface->LineTo(endX, endY); x += 4; } } else if (style == INDIC_STRIKE) { - surface->MoveTo(rc.left, rc.top - 4); - surface->LineTo(rc.right, rc.top - 4); + surface->MoveTo(static_cast<int>(rc.left), static_cast<int>(rc.top) - 4); + surface->LineTo(static_cast<int>(rc.right), static_cast<int>(rc.top) - 4); } else if (style == INDIC_HIDDEN) { // Draw nothing } else if (style == INDIC_BOX) { - surface->MoveTo(rc.left, ymid+1); - surface->LineTo(rc.right, ymid+1); - surface->LineTo(rc.right, rcLine.top+1); - surface->LineTo(rc.left, rcLine.top+1); - surface->LineTo(rc.left, ymid+1); + surface->MoveTo(static_cast<int>(rc.left), ymid + 1); + surface->LineTo(static_cast<int>(rc.right), ymid + 1); + surface->LineTo(static_cast<int>(rc.right), static_cast<int>(rcLine.top) + 1); + surface->LineTo(static_cast<int>(rc.left), static_cast<int>(rcLine.top) + 1); + surface->LineTo(static_cast<int>(rc.left), ymid + 1); } else if (style == INDIC_ROUNDBOX || style == INDIC_STRAIGHTBOX) { PRectangle rcBox = rcLine; rcBox.top = rcLine.top + 1; @@ -123,32 +123,32 @@ void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &r rcBox.top = rcLine.top + 1; rcBox.bottom = rcLine.bottom; // Cap width at 4000 to avoid large allocations when mistakes made - int width = Platform::Minimum(rcBox.Width(), 4000); - RGBAImage image(width, rcBox.Height(), 1.0, 0); + int width = Platform::Minimum(static_cast<int>(rcBox.Width()), 4000); + RGBAImage image(width, static_cast<int>(rcBox.Height()), 1.0, 0); // Draw horizontal lines top and bottom for (int x=0; x<width; x++) { - for (int y=0; y<rcBox.Height(); y += rcBox.Height()-1) { + for (int y = 0; y<static_cast<int>(rcBox.Height()); y += static_cast<int>(rcBox.Height()) - 1) { image.SetPixel(x, y, fore, ((x + y) % 2) ? outlineAlpha : fillAlpha); } } // Draw vertical lines left and right - for (int y=1; y<rcBox.Height(); y++) { + for (int y = 1; y<static_cast<int>(rcBox.Height()); y++) { for (int x=0; x<width; x += width-1) { image.SetPixel(x, y, fore, ((x + y) % 2) ? outlineAlpha : fillAlpha); } } surface->DrawRGBAImage(rcBox, image.GetWidth(), image.GetHeight(), image.Pixels()); } else if (style == INDIC_DASH) { - int x = rc.left; + int x = static_cast<int>(rc.left); while (x < rc.right) { surface->MoveTo(x, ymid); - surface->LineTo(Platform::Minimum(x + 4, rc.right), ymid); + surface->LineTo(Platform::Minimum(x + 4, static_cast<int>(rc.right)), ymid); x += 7; } } else if (style == INDIC_DOTS) { - int x = rc.left; - while (x < rc.right) { - PRectangle rcDot(x, ymid, x+1, ymid+1); + int x = static_cast<int>(rc.left); + while (x < static_cast<int>(rc.right)) { + PRectangle rcDot = PRectangle::FromInts(x, ymid, x + 1, ymid + 1); surface->FillRectangle(rcDot, fore); x += 2; } @@ -156,8 +156,8 @@ void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &r PRectangle rcComposition(rc.left+1, rcLine.bottom-2, rc.right-1, rcLine.bottom); surface->FillRectangle(rcComposition, fore); } else { // Either INDIC_PLAIN or unknown - surface->MoveTo(rc.left, ymid); - surface->LineTo(rc.right, ymid); + surface->MoveTo(static_cast<int>(rc.left), ymid); + surface->LineTo(static_cast<int>(rc.right), ymid); } }

Modified: scintilla/src/LineMarker.cxx 168 lines changed, 84 insertions(+), 84 deletions(-) =================================================================== @@ -37,37 +37,37 @@ void LineMarker::SetXPM(const char *const *linesForm) {

void LineMarker::SetRGBAImage(Point sizeRGBAImage, float scale, const unsigned char *pixelsRGBAImage) { delete image; - image = new RGBAImage(sizeRGBAImage.x, sizeRGBAImage.y, scale, pixelsRGBAImage); + image = new RGBAImage(static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y), scale, pixelsRGBAImage); markType = SC_MARK_RGBAIMAGE; }

static void DrawBox(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore, ColourDesired back) { - PRectangle rc; - rc.left = centreX - armSize; - rc.top = centreY - armSize; - rc.right = centreX + armSize + 1; - rc.bottom = centreY + armSize + 1; + PRectangle rc = PRectangle::FromInts( + centreX - armSize, + centreY - armSize, + centreX + armSize + 1, + centreY + armSize + 1); surface->RectangleDraw(rc, back, fore); }

static void DrawCircle(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore, ColourDesired back) { - PRectangle rcCircle; - rcCircle.left = centreX - armSize; - rcCircle.top = centreY - armSize; - rcCircle.right = centreX + armSize + 1; - rcCircle.bottom = centreY + armSize + 1; + PRectangle rcCircle = PRectangle::FromInts( + centreX - armSize, + centreY - armSize, + centreX + armSize + 1, + centreY + armSize + 1); surface->Ellipse(rcCircle, back, fore); }

static void DrawPlus(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore) { - PRectangle rcV(centreX, centreY - armSize + 2, centreX + 1, centreY + armSize - 2 + 1); + PRectangle rcV = PRectangle::FromInts(centreX, centreY - armSize + 2, centreX + 1, centreY + armSize - 2 + 1); surface->FillRectangle(rcV, fore); - PRectangle rcH(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY+1); + PRectangle rcH = PRectangle::FromInts(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY + 1); surface->FillRectangle(rcH, fore); }

static void DrawMinus(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore) { - PRectangle rcH(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY+1); + PRectangle rcH = PRectangle::FromInts(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY + 1); surface->FillRectangle(rcH, fore); }

@@ -102,9 +102,9 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac if ((markType == SC_MARK_RGBAIMAGE) && (image)) { // Make rectangle just large enough to fit image centred on centre of rcWhole PRectangle rcImage; - rcImage.top = static_cast<int>(((rcWhole.top + rcWhole.bottom) - image->GetScaledHeight()) / 2); + rcImage.top = ((rcWhole.top + rcWhole.bottom) - image->GetScaledHeight()) / 2; rcImage.bottom = rcImage.top + image->GetScaledHeight(); - rcImage.left = static_cast<int>(((rcWhole.left + rcWhole.right) - image->GetScaledWidth()) / 2); + rcImage.left = ((rcWhole.left + rcWhole.right) - image->GetScaledWidth()) / 2; rcImage.right = rcImage.left + image->GetScaledWidth(); surface->DrawRGBAImage(rcImage, image->GetWidth(), image->GetHeight(), image->Pixels()); return; @@ -113,17 +113,17 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac PRectangle rc = rcWhole; rc.top++; rc.bottom--; - int minDim = Platform::Minimum(rc.Width(), rc.Height()); + int minDim = Platform::Minimum(static_cast<int>(rc.Width()), static_cast<int>(rc.Height())); minDim--; // Ensure does not go beyond edge - int centreX = floor((rc.right + rc.left) / 2.0); - int centreY = floor((rc.bottom + rc.top) / 2.0); + int centreX = static_cast<int>(floor((rc.right + rc.left) / 2.0)); + int centreY = static_cast<int>(floor((rc.bottom + rc.top) / 2.0)); int dimOn2 = minDim / 2; int dimOn4 = minDim / 4; int blobSize = dimOn2-1; int armSize = dimOn2-2; if (marginStyle == SC_MARGIN_NUMBER || marginStyle == SC_MARGIN_TEXT || marginStyle == SC_MARGIN_RTEXT) { // On textual margins move marker to the left to try to avoid overlapping the text - centreX = rc.left + dimOn2 + 1; + centreX = static_cast<int>(rc.left) + dimOn2 + 1; } if (markType == SC_MARK_ROUNDRECT) { PRectangle rcRounded = rc; @@ -131,51 +131,51 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac rcRounded.right = rc.right - 1; surface->RoundedRectangle(rcRounded, fore, back); } else if (markType == SC_MARK_CIRCLE) { - PRectangle rcCircle; - rcCircle.left = centreX - dimOn2; - rcCircle.top = centreY - dimOn2; - rcCircle.right = centreX + dimOn2; - rcCircle.bottom = centreY + dimOn2; + PRectangle rcCircle = PRectangle::FromInts( + centreX - dimOn2, + centreY - dimOn2, + centreX + dimOn2, + centreY + dimOn2); surface->Ellipse(rcCircle, fore, back); } else if (markType == SC_MARK_ARROW) { Point pts[] = { - Point(centreX - dimOn4, centreY - dimOn2), - Point(centreX - dimOn4, centreY + dimOn2), - Point(centreX + dimOn2 - dimOn4, centreY), + Point::FromInts(centreX - dimOn4, centreY - dimOn2), + Point::FromInts(centreX - dimOn4, centreY + dimOn2), + Point::FromInts(centreX + dimOn2 - dimOn4, centreY), }; surface->Polygon(pts, ELEMENTS(pts), fore, back);

} else if (markType == SC_MARK_ARROWDOWN) { Point pts[] = { - Point(centreX - dimOn2, centreY - dimOn4), - Point(centreX + dimOn2, centreY - dimOn4), - Point(centreX, centreY + dimOn2 - dimOn4), + Point::FromInts(centreX - dimOn2, centreY - dimOn4), + Point::FromInts(centreX + dimOn2, centreY - dimOn4), + Point::FromInts(centreX, centreY + dimOn2 - dimOn4), }; surface->Polygon(pts, ELEMENTS(pts), fore, back);

} else if (markType == SC_MARK_PLUS) { Point pts[] = { - Point(centreX - armSize, centreY - 1), - Point(centreX - 1, centreY - 1), - Point(centreX - 1, centreY - armSize), - Point(centreX + 1, centreY - armSize), - Point(centreX + 1, centreY - 1), - Point(centreX + armSize, centreY -1), - Point(centreX + armSize, centreY +1), - Point(centreX + 1, centreY + 1), - Point(centreX + 1, centreY + armSize), - Point(centreX - 1, centreY + armSize), - Point(centreX - 1, centreY + 1), - Point(centreX - armSize, centreY + 1), + Point::FromInts(centreX - armSize, centreY - 1), + Point::FromInts(centreX - 1, centreY - 1), + Point::FromInts(centreX - 1, centreY - armSize), + Point::FromInts(centreX + 1, centreY - armSize), + Point::FromInts(centreX + 1, centreY - 1), + Point::FromInts(centreX + armSize, centreY -1), + Point::FromInts(centreX + armSize, centreY +1), + Point::FromInts(centreX + 1, centreY + 1), + Point::FromInts(centreX + 1, centreY + armSize), + Point::FromInts(centreX - 1, centreY + armSize), + Point::FromInts(centreX - 1, centreY + 1), + Point::FromInts(centreX - armSize, centreY + 1), }; surface->Polygon(pts, ELEMENTS(pts), fore, back);

} else if (markType == SC_MARK_MINUS) { Point pts[] = { - Point(centreX - armSize, centreY - 1), - Point(centreX + armSize, centreY -1), - Point(centreX + armSize, centreY +1), - Point(centreX - armSize, centreY + 1), + Point::FromInts(centreX - armSize, centreY - 1), + Point::FromInts(centreX + armSize, centreY -1), + Point::FromInts(centreX + armSize, centreY +1), + Point::FromInts(centreX - armSize, centreY + 1), }; surface->Polygon(pts, ELEMENTS(pts), fore, back);

@@ -193,46 +193,46 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac

} else if (markType == SC_MARK_VLINE) { surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); - surface->LineTo(centreX, rcWhole.bottom); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

} else if (markType == SC_MARK_LCORNER) { surface->PenColour(tail); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY); - surface->LineTo(rc.right - 1, centreY); + surface->LineTo(static_cast<int>(rc.right) - 1, centreY);

} else if (markType == SC_MARK_TCORNER) { surface->PenColour(tail); surface->MoveTo(centreX, centreY); - surface->LineTo(rc.right - 1, centreY); + surface->LineTo(static_cast<int>(rc.right) - 1, centreY);

surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY + 1);

surface->PenColour(head); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

} else if (markType == SC_MARK_LCORNERCURVE) { surface->PenColour(tail); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY-3); surface->LineTo(centreX+3, centreY); - surface->LineTo(rc.right - 1, centreY); + surface->LineTo(static_cast<int>(rc.right) - 1, centreY);

} else if (markType == SC_MARK_TCORNERCURVE) { surface->PenColour(tail); surface->MoveTo(centreX, centreY-3); surface->LineTo(centreX+3, centreY); - surface->LineTo(rc.right - 1, centreY); + surface->LineTo(static_cast<int>(rc.right) - 1, centreY);

surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY-2);

surface->PenColour(head); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

} else if (markType == SC_MARK_BOXPLUS) { DrawBox(surface, centreX, centreY, blobSize, fore, head); @@ -244,10 +244,10 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac else surface->PenColour(body); surface->MoveTo(centreX, centreY + blobSize); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY - blobSize);

DrawBox(surface, centreX, centreY, blobSize, fore, head); @@ -270,7 +270,7 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac

surface->PenColour(head); surface->MoveTo(centreX, centreY + blobSize); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

} else if (markType == SC_MARK_BOXMINUSCONNECTED) { DrawBox(surface, centreX, centreY, blobSize, fore, head); @@ -278,10 +278,10 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac

surface->PenColour(head); surface->MoveTo(centreX, centreY + blobSize); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY - blobSize);

if (tFold == LineMarker::body) { @@ -305,10 +305,10 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac else surface->PenColour(body); surface->MoveTo(centreX, centreY + blobSize); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY - blobSize);

DrawCircle(surface, centreX, centreY, blobSize, fore, head); @@ -317,7 +317,7 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac } else if (markType == SC_MARK_CIRCLEMINUS) { surface->PenColour(head); surface->MoveTo(centreX, centreY + blobSize); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

DrawCircle(surface, centreX, centreY, blobSize, fore, head); DrawMinus(surface, centreX, centreY, blobSize, tail); @@ -325,10 +325,10 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac } else if (markType == SC_MARK_CIRCLEMINUSCONNECTED) { surface->PenColour(head); surface->MoveTo(centreX, centreY + blobSize); - surface->LineTo(centreX, rcWhole.bottom); + surface->LineTo(centreX, static_cast<int>(rcWhole.bottom));

surface->PenColour(body); - surface->MoveTo(centreX, rcWhole.top); + surface->MoveTo(centreX, static_cast<int>(rcWhole.top)); surface->LineTo(centreX, centreY - blobSize);

DrawCircle(surface, centreX, centreY, blobSize, fore, head); @@ -344,11 +344,11 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac character, 1, fore, back);

} else if (markType == SC_MARK_DOTDOTDOT) { - int right = centreX - 6; + XYPOSITION right = static_cast<XYPOSITION>(centreX - 6); for (int b=0; b<3; b++) { PRectangle rcBlob(right, rc.bottom - 4, right + 2, rc.bottom-2); surface->FillRectangle(rcBlob, fore); - right += 5; + right += 5.0f; } } else if (markType == SC_MARK_ARROWS) { surface->PenColour(fore); @@ -363,14 +363,14 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac } } else if (markType == SC_MARK_SHORTARROW) { Point pts[] = { - Point(centreX, centreY + dimOn2), - Point(centreX + dimOn2, centreY), - Point(centreX, centreY - dimOn2), - Point(centreX, centreY - dimOn4), - Point(centreX - dimOn4, centreY - dimOn4), - Point(centreX - dimOn4, centreY + dimOn4), - Point(centreX, centreY + dimOn4), - Point(centreX, centreY + dimOn2), + Point::FromInts(centreX, centreY + dimOn2), + Point::FromInts(centreX + dimOn2, centreY), + Point::FromInts(centreX, centreY - dimOn2), + Point::FromInts(centreX, centreY - dimOn4), + Point::FromInts(centreX - dimOn4, centreY - dimOn4), + Point::FromInts(centreX - dimOn4, centreY + dimOn4), + Point::FromInts(centreX, centreY + dimOn4), + Point::FromInts(centreX, centreY + dimOn2), }; surface->Polygon(pts, ELEMENTS(pts), fore, back); } else if (markType == SC_MARK_LEFTRECT) { @@ -380,11 +380,11 @@ void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharac } else if (markType == SC_MARK_BOOKMARK) { int halfHeight = minDim / 3; Point pts[] = { - Point(rc.left, centreY-halfHeight), - Point(rc.right-3, centreY-halfHeight), - Point(rc.right-3-halfHeight, centreY), - Point(rc.right-3, centreY+halfHeight), - Point(rc.left, centreY+halfHeight), + Point::FromInts(static_cast<int>(rc.left), centreY-halfHeight), + Point::FromInts(static_cast<int>(rc.right) - 3, centreY - halfHeight), + Point::FromInts(static_cast<int>(rc.right) - 3 - halfHeight, centreY), + Point::FromInts(static_cast<int>(rc.right) - 3, centreY + halfHeight), + Point::FromInts(static_cast<int>(rc.left), centreY + halfHeight), }; surface->Polygon(pts, ELEMENTS(pts), fore, back); } else { // SC_MARK_FULLRECT

Modified: scintilla/src/PositionCache.cxx 19 lines changed, 10 insertions(+), 9 deletions(-) =================================================================== @@ -232,7 +232,7 @@ Point LineLayout::PointFromPosition(int posInLine, int lineHeight) const { for (int subLine = 0; subLine < lines; subLine++) { const Range rangeSubLine = SubLineRange(subLine); if (posInLine >= rangeSubLine.start) { - pt.y = subLine*lineHeight; + pt.y = static_cast<XYPOSITION>(subLine*lineHeight); if (posInLine <= rangeSubLine.end) { pt.x = positions[posInLine] - positions[rangeSubLine.start]; if (rangeSubLine.start != 0) // Wrapped lines may be indented @@ -462,7 +462,7 @@ BreakFinder::BreakFinder(LineLayout *ll_, int lineStart_, int lineEnd_, int posL // Search for first visible break // First find the first visible character if (xStart > 0.0f) - nextBreak = ll->FindBefore(xStart, lineStart, lineEnd); + nextBreak = ll->FindBefore(static_cast<XYPOSITION>(xStart), lineStart, lineEnd); // Now back to a style break while ((nextBreak > lineStart) && (ll->styles[nextBreak] == ll->styles[nextBreak - 1])) { nextBreak--; @@ -563,7 +563,7 @@ void PositionCacheEntry::Set(unsigned int styleNumber_, const char *s_, if (s_ && positions_) { positions = new XYPOSITION[len + (len / 4) + 1]; for (unsigned int i=0; i<len; i++) { - positions[i] = static_cast<XYPOSITION>(positions_[i]); + positions[i] = positions_[i]; } memcpy(reinterpret_cast<char *>(positions + len), s_, len); } @@ -594,7 +594,7 @@ bool PositionCacheEntry::Retrieve(unsigned int styleNumber_, const char *s_, } }

-int PositionCacheEntry::Hash(unsigned int styleNumber_, const char *s, unsigned int len_) { +unsigned int PositionCacheEntry::Hash(unsigned int styleNumber_, const char *s, unsigned int len_) { unsigned int ret = s[0] << 7; for (unsigned int i=0; i<len_; i++) { ret *= 1000003; @@ -646,18 +646,18 @@ void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned const char *s, unsigned int len, XYPOSITION *positions, Document *pdoc) {

allClear = false; - int probe = -1; + size_t probe = pces.size(); // Out of bounds if ((!pces.empty()) && (len < 30)) { // Only store short strings in the cache so it doesn't churn with // long comments with only a single comment.

// Two way associative: try two probe positions. - int hashValue = PositionCacheEntry::Hash(styleNumber, s, len); - probe = static_cast<int>(hashValue % pces.size()); + unsigned int hashValue = PositionCacheEntry::Hash(styleNumber, s, len); + probe = hashValue % pces.size(); if (pces[probe].Retrieve(styleNumber, s, len, positions)) { return; } - int probe2 = static_cast<int>((hashValue * 37) % pces.size()); + unsigned int probe2 = (hashValue * 37) % pces.size(); if (pces[probe2].Retrieve(styleNumber, s, len, positions)) { return; } @@ -682,7 +682,8 @@ void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned } else { surface->MeasureWidths(vstyle.styles[styleNumber].font, s, len, positions); } - if (probe >= 0) { + if (probe < pces.size()) { + // Store into cache clock++; if (clock > 60000) { // Since there are only 16 bits for the clock, wrap it round and

Modified: scintilla/src/PositionCache.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -111,7 +111,7 @@ class PositionCacheEntry { void Set(unsigned int styleNumber_, const char *s_, unsigned int len_, XYPOSITION *positions_, unsigned int clock); void Clear(); bool Retrieve(unsigned int styleNumber_, const char *s_, unsigned int len_, XYPOSITION *positions_) const; - static int Hash(unsigned int styleNumber_, const char *s, unsigned int len); + static unsigned int Hash(unsigned int styleNumber_, const char *s, unsigned int len); bool NewerThan(const PositionCacheEntry &other) const; void ResetClock(); };

Modified: scintilla/src/RESearch.cxx 5 lines changed, 0 insertions(+), 5 deletions(-) =================================================================== @@ -207,11 +207,6 @@ #include "CharClassify.h" #include "RESearch.h"

-// Shut up annoying Visual C++ warnings: -#ifdef _MSC_VER -#pragma warning(disable: 4514) -#endif - #ifdef SCI_NAMESPACE using namespace Scintilla; #endif

Modified: scintilla/src/ScintillaBase.cxx 59 lines changed, 30 insertions(+), 29 deletions(-) =================================================================== @@ -198,8 +198,8 @@ void ScintillaBase::AutoCompleteDoubleClick(void *p) { void ScintillaBase::AutoCompleteInsert(Position startPos, int removeLen, const char *text, int textLen) { UndoGroup ug(pdoc); pdoc->DeleteChars(startPos, removeLen); - pdoc->InsertString(startPos, text, textLen); - SetEmptySelection(startPos + textLen); + const int lengthInserted = pdoc->InsertString(startPos, text, textLen); + SetEmptySelection(startPos + lengthInserted); }

void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) { @@ -233,7 +233,7 @@ void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) { int heightLB = ac.heightLBDefault; int widthLB = ac.widthLBDefault; if (pt.x >= rcClient.right - widthLB) { - HorizontalScrollTo(xOffset + pt.x - rcClient.right + widthLB); + HorizontalScrollTo(static_cast<int>(xOffset + pt.x - rcClient.right + widthLB)); Redraw(); pt = PointMainCaret(); } @@ -248,17 +248,17 @@ void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) { pt.y >= (rcPopupBounds.bottom + rcPopupBounds.top) / 2) { // and there is more room above. rcac.top = pt.y - heightLB; if (rcac.top < rcPopupBounds.top) { - heightLB -= (rcPopupBounds.top - rcac.top); + heightLB -= static_cast<int>(rcPopupBounds.top - rcac.top); rcac.top = rcPopupBounds.top; } } else { rcac.top = pt.y + vs.lineHeight; } rcac.right = rcac.left + widthLB; - rcac.bottom = Platform::Minimum(rcac.top + heightLB, rcPopupBounds.bottom); + rcac.bottom = static_cast<XYPOSITION>(Platform::Minimum(static_cast<int>(rcac.top) + heightLB, static_cast<int>(rcPopupBounds.bottom))); ac.lb->SetPositionRelative(rcac, wMain); ac.lb->SetFont(vs.styles[STYLE_DEFAULT].font); - unsigned int aveCharWidth = vs.styles[STYLE_DEFAULT].aveCharWidth; + unsigned int aveCharWidth = static_cast<unsigned int>(vs.styles[STYLE_DEFAULT].aveCharWidth); ac.lb->SetAverageCharWidth(aveCharWidth); ac.lb->SetDoubleClickAction(AutoCompleteDoubleClick, this);

@@ -266,8 +266,8 @@ void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) {

// Fiddle the position of the list so it is right next to the target and wide enough for all its strings PRectangle rcList = ac.lb->GetDesiredRect(); - int heightAlloced = rcList.bottom - rcList.top; - widthLB = Platform::Maximum(widthLB, rcList.right - rcList.left); + int heightAlloced = static_cast<int>(rcList.bottom - rcList.top); + widthLB = Platform::Maximum(widthLB, static_cast<int>(rcList.right - rcList.left)); if (maxListWidth != 0) widthLB = Platform::Minimum(widthLB, aveCharWidth*maxListWidth); // Make an allowance for large strings in list @@ -416,7 +416,7 @@ void ScintillaBase::CallTipShow(Point pt, const char *defn) { // If the call-tip window would be out of the client // space PRectangle rcClient = GetClientRectangle(); - int offset = vs.lineHeight + rc.Height(); + int offset = vs.lineHeight + static_cast<int>(rc.Height()); // adjust so it displays above the text. if (rc.bottom > rcClient.bottom) { rc.top -= offset; @@ -749,7 +749,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara switch (iMessage) { case SCI_AUTOCSHOW: listType = 0; - AutoCompleteStart(wParam, reinterpret_cast<const char *>(lParam)); + AutoCompleteStart(static_cast<int>(wParam), reinterpret_cast<const char *>(lParam)); break;

case SCI_AUTOCCANCEL: @@ -813,21 +813,21 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara return ac.ignoreCase;

case SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR: - ac.ignoreCaseBehaviour = wParam; + ac.ignoreCaseBehaviour = static_cast<unsigned int>(wParam); break;

case SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR: return ac.ignoreCaseBehaviour;

case SCI_AUTOCSETORDER: - ac.autoSort = wParam; + ac.autoSort = static_cast<int>(wParam); break;

case SCI_AUTOCGETORDER: return ac.autoSort;

case SCI_USERLISTSHOW: - listType = wParam; + listType = static_cast<int>(wParam); AutoCompleteStart(0, reinterpret_cast<const char *>(lParam)); break;

@@ -846,25 +846,26 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara return ac.dropRestOfWord;

case SCI_AUTOCSETMAXHEIGHT: - ac.lb->SetVisibleRows(wParam); + ac.lb->SetVisibleRows(static_cast<int>(wParam)); break;

case SCI_AUTOCGETMAXHEIGHT: return ac.lb->GetVisibleRows();

case SCI_AUTOCSETMAXWIDTH: - maxListWidth = wParam; + maxListWidth = static_cast<int>(wParam); break;

case SCI_AUTOCGETMAXWIDTH: return maxListWidth;

case SCI_REGISTERIMAGE: - ac.lb->RegisterImage(wParam, reinterpret_cast<const char *>(lParam)); + ac.lb->RegisterImage(static_cast<int>(wParam), reinterpret_cast<const char *>(lParam)); break;

case SCI_REGISTERRGBAIMAGE: - ac.lb->RegisterRGBAImage(wParam, sizeRGBAImage.x, sizeRGBAImage.y, reinterpret_cast<unsigned char *>(lParam)); + ac.lb->RegisterRGBAImage(static_cast<int>(wParam), static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y), + reinterpret_cast<unsigned char *>(lParam)); break;

case SCI_CLEARREGISTEREDIMAGES: @@ -879,7 +880,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara return ac.GetTypesep();

case SCI_CALLTIPSHOW: - CallTipShow(LocationFromPosition(wParam), + CallTipShow(LocationFromPosition(static_cast<int>(wParam)), reinterpret_cast<const char *>(lParam)); break;

@@ -894,32 +895,32 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara return ct.posStartCallTip;

case SCI_CALLTIPSETPOSSTART: - ct.posStartCallTip = wParam; + ct.posStartCallTip = static_cast<int>(wParam); break;

case SCI_CALLTIPSETHLT: - ct.SetHighlight(wParam, lParam); + ct.SetHighlight(static_cast<int>(wParam), static_cast<int>(lParam)); break;

case SCI_CALLTIPSETBACK: - ct.colourBG = ColourDesired(wParam); + ct.colourBG = ColourDesired(static_cast<long>(wParam)); vs.styles[STYLE_CALLTIP].back = ct.colourBG; InvalidateStyleRedraw(); break;

case SCI_CALLTIPSETFORE: - ct.colourUnSel = ColourDesired(wParam); + ct.colourUnSel = ColourDesired(static_cast<long>(wParam)); vs.styles[STYLE_CALLTIP].fore = ct.colourUnSel; InvalidateStyleRedraw(); break;

case SCI_CALLTIPSETFOREHLT: - ct.colourSel = ColourDesired(wParam); + ct.colourSel = ColourDesired(static_cast<long>(wParam)); InvalidateStyleRedraw(); break;

case SCI_CALLTIPUSESTYLE: - ct.SetTabSize((int)wParam); + ct.SetTabSize(static_cast<int>(wParam)); InvalidateStyleRedraw(); break;

@@ -934,7 +935,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara

#ifdef SCI_LEXER case SCI_SETLEXER: - DocumentLexState()->SetLexer(wParam); + DocumentLexState()->SetLexer(static_cast<int>(wParam)); break;

case SCI_GETLEXER: @@ -942,10 +943,10 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara

case SCI_COLOURISE: if (DocumentLexState()->lexLanguage == SCLEX_CONTAINER) { - pdoc->ModifiedAt(wParam); - NotifyStyleToNeeded((lParam == -1) ? pdoc->Length() : lParam); + pdoc->ModifiedAt(static_cast<int>(wParam)); + NotifyStyleToNeeded((lParam == -1) ? pdoc->Length() : static_cast<int>(lParam)); } else { - DocumentLexState()->Colourise(wParam, lParam); + DocumentLexState()->Colourise(static_cast<int>(wParam), static_cast<int>(lParam)); } Redraw(); break; @@ -963,7 +964,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara reinterpret_cast<char *>(lParam));

case SCI_GETPROPERTYINT: - return DocumentLexState()->PropGetInt(reinterpret_cast<const char *>(wParam), lParam); + return DocumentLexState()->PropGetInt(reinterpret_cast<const char *>(wParam), static_cast<int>(lParam));

case SCI_SETKEYWORDS: DocumentLexState()->SetWordList(wParam, reinterpret_cast<const char *>(lParam));

Modified: scintilla/src/Selection.cxx 8 lines changed, 8 insertions(+), 0 deletions(-) =================================================================== @@ -230,6 +230,14 @@ SelectionRange &Selection::RangeMain() { return ranges[mainRange]; }

+SelectionPosition Selection::Start() const { + if (IsRectangular()) { + return rangeRectangular.Start(); + } else { + return ranges[mainRange].Start(); + } +} + bool Selection::MoveExtends() const { return moveExtends; }

Modified: scintilla/src/Selection.h 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -157,6 +157,7 @@ class Selection { void SetMain(size_t r); SelectionRange &Range(size_t r); SelectionRange &RangeMain(); + SelectionPosition Start() const; bool MoveExtends() const; void SetMoveExtends(bool moveExtends_); bool Empty() const;

Modified: scintilla/src/ViewStyle.cxx 8 lines changed, 4 insertions(+), 4 deletions(-) =================================================================== @@ -75,12 +75,12 @@ void FontRealised::Realise(Surface &surface, int zoomLevel, int technology, cons if (sizeZoomed <= 2 * SC_FONT_SIZE_MULTIPLIER) // Hangs if sizeZoomed <= 1 sizeZoomed = 2 * SC_FONT_SIZE_MULTIPLIER;

- float deviceHeight = surface.DeviceHeightFont(sizeZoomed); + float deviceHeight = static_cast<float>(surface.DeviceHeightFont(sizeZoomed)); FontParameters fp(fs.fontName, deviceHeight / SC_FONT_SIZE_MULTIPLIER, fs.weight, fs.italic, fs.extraFontFlag, technology, fs.charact@@ Diff output truncated at 100000 characters. @@

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