[geany/geany] e56643: Merge branch 'scintilla-update-342'
Colomban Wendling
git-noreply at xxxxx
Sat May 17 20:23:43 UTC 2014
Branch: refs/heads/master
Author: Colomban Wendling <ban at herbesfolles.org>
Committer: Colomban Wendling <ban at herbesfolles.org>
Date: Sat, 17 May 2014 20:23:43 UTC
Commit: e566435dfae4e410f65efbb463f682221788354c
https://github.com/geany/geany/commit/e566435dfae4e410f65efbb463f682221788354c
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::vector<std::string> StringSplit(const std::string &text, int separator) {
+ std::vector<std::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::vector<std::string>::iterator itBracket;
+ std::vector<std::string>::iterator itEndBracket;
+};
+
+BracketPair FindBracketPair(std::vector<std::string> &tokens) {
+ BracketPair bp;
+ std::vector<std::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::vector<std::string> Tokenize(const std::string &s) {
- // Break into space separated tokens
- std::string word;
- std::vector<std::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;
SparseState<std::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::vector<std::string> &tokens);
- bool EvaluateExpression(const std::string &expr, const std::map<std::string, std::string> &preprocessorDefinitions);
+ void EvaluateTokens(std::vector<std::string> &tokens, const SymbolTable &preprocessorDefinitions);
+ std::vector<std::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::vector<std::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::vector<std::string> &tokens) {
+void LexerCPP::EvaluateTokens(std::vector<std::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::vector<std::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::vector<std::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::vector<std::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::vector<std::string>::iterator itBracket = std::find(tokens.begin(), tokens.end(), "(");
- std::vector<std::string>::iterator itEndBracket = std::find(tokens.begin(), tokens.end(), ")");
- while ((itBracket != tokens.end()) && (itEndBracket != tokens.end()) && (itEndBracket > itBracket)) {
- std::vector<std::string> inBracket(itBracket + 1, itEndBracket);
- EvaluateTokens(inBracket);
+ BracketPair bracketPair = FindBracketPair(tokens);
+ while (bracketPair.itBracket != tokens.end()) {
+ std::vector<std::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::vector<std::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::vector<std::string> LexerCPP::Tokenize(const std::string &expr) const {
+ // Break into tokens
std::vector<std::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::vector<std::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).
More information about the Commits
mailing list