From 4cb233a71be62470dad773f3b891ef6c74c65227 Mon Sep 17 00:00:00 2001
From: Sven Strickroth <email@cs-ware.de>
Date: Mon, 26 Jan 2015 17:48:24 +0100
Subject: [PATCH] Update Scintilla to version 3.5.3

Signed-off-by: Sven Strickroth <email@cs-ware.de>
---
 ext/build/ScintillaLexer.vcxproj         |    1 +
 ext/build/ScintillaLexer.vcxproj.filters |    3 +
 ext/scintilla/cppcheck.suppress          |    1 +
 ext/scintilla/delbin.bat                 |    1 -
 ext/scintilla/delcvs.bat                 |    1 -
 ext/scintilla/doc/ScintillaDoc.html      |   13 +-
 ext/scintilla/doc/ScintillaDownload.html |   10 +-
 ext/scintilla/doc/ScintillaHistory.html  |   71 ++
 ext/scintilla/doc/index.html             |    7 +-
 ext/scintilla/include/Platform.h         |    5 +
 ext/scintilla/include/SciLexer.h         |   27 +
 ext/scintilla/include/Scintilla.h        |    1 -
 ext/scintilla/include/Scintilla.iface    |   33 +
 ext/scintilla/lexers/LexBash.cxx         |   14 +-
 ext/scintilla/lexers/LexCPP.cxx          |    4 +-
 ext/scintilla/lexers/LexHex.cxx          | 1045 ++++++++++++++++++++++++++++++
 ext/scintilla/lexers/LexVerilog.cxx      |  876 +++++++++++++++++++++----
 ext/scintilla/lexlib/LexAccessor.h       |    3 +
 ext/scintilla/lexlib/WordList.cxx        |    2 +
 ext/scintilla/src/Catalogue.cxx          |    3 +
 ext/scintilla/src/Document.cxx           |   18 +-
 ext/scintilla/src/EditView.cxx           |   14 +-
 ext/scintilla/src/EditView.h             |    1 -
 ext/scintilla/src/Editor.cxx             |   27 +-
 ext/scintilla/src/Editor.h               |    2 +-
 ext/scintilla/src/MarginView.cxx         |   18 +-
 ext/scintilla/src/ScintillaBase.cxx      |    4 +-
 ext/scintilla/src/UniConversion.cxx      |   14 +-
 ext/scintilla/src/UniConversion.h        |    4 +-
 ext/scintilla/tgzsrc                     |    4 -
 ext/scintilla/tortoisegit.txt            |    2 +-
 ext/scintilla/unicodefont.patch          |  161 -----
 ext/scintilla/version.txt                |    2 +-
 ext/scintilla/win32/PlatWin.cxx          |   75 +--
 ext/scintilla/win32/PlatWin.h            |    1 -
 ext/scintilla/win32/ScintRes.rc          |    4 +-
 ext/scintilla/win32/ScintillaWin.cxx     |  339 ++++++----
 ext/scintilla/win32/scintilla.mak        |    3 +
 ext/scintilla/zipsrc.bat                 |    4 -
 39 files changed, 2226 insertions(+), 592 deletions(-)
 delete mode 100644 ext/scintilla/delbin.bat
 delete mode 100644 ext/scintilla/delcvs.bat
 create mode 100644 ext/scintilla/lexers/LexHex.cxx
 delete mode 100644 ext/scintilla/tgzsrc
 delete mode 100644 ext/scintilla/unicodefont.patch
 delete mode 100644 ext/scintilla/zipsrc.bat

diff --git a/ext/build/ScintillaLexer.vcxproj b/ext/build/ScintillaLexer.vcxproj
index f13b924b3..25fe25c6f 100644
--- a/ext/build/ScintillaLexer.vcxproj
+++ b/ext/build/ScintillaLexer.vcxproj
@@ -55,6 +55,7 @@
     <ClCompile Include="..\scintilla\lexers\LexBibTeX.cxx" />
     <ClCompile Include="..\scintilla\lexers\LexDMAP.cxx" />
     <ClCompile Include="..\scintilla\lexers\LexDMIS.cxx" />
+    <ClCompile Include="..\scintilla\lexers\LexHex.cxx" />
     <ClCompile Include="..\scintilla\lexers\LexKVIrc.cxx" />
     <ClCompile Include="..\scintilla\lexers\LexLaTeX.cxx" />
     <ClCompile Include="..\scintilla\lexers\LexRegistry.cxx" />
diff --git a/ext/build/ScintillaLexer.vcxproj.filters b/ext/build/ScintillaLexer.vcxproj.filters
index e4a313eb1..50ed6589c 100644
--- a/ext/build/ScintillaLexer.vcxproj.filters
+++ b/ext/build/ScintillaLexer.vcxproj.filters
@@ -430,6 +430,9 @@
     <ClCompile Include="..\scintilla\src\MarginView.cxx">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\scintilla\lexers\LexHex.cxx">
+      <Filter>lexers</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\scintilla\src\AutoComplete.h">
diff --git a/ext/scintilla/cppcheck.suppress b/ext/scintilla/cppcheck.suppress
index 10bf9dbf3..5a973db87 100644
--- a/ext/scintilla/cppcheck.suppress
+++ b/ext/scintilla/cppcheck.suppress
@@ -30,6 +30,7 @@ variableScope:scintilla/lexers/LexRuby.cxx
 uninitMemberVar:scintilla/lexers/LexRuby.cxx
 variableScope:scintilla/lexers/LexSpecman.cxx
 unreadVariable:scintilla/lexers/LexSpice.cxx
+clarifyCalculation:scintilla/lexers/LexTADS3.cxx
 invalidscanf:scintilla/lexers/LexTCMD.cxx
 variableScope:scintilla/lexers/LexTeX.cxx
 variableScope:scintilla/lexers/LexVHDL.cxx
diff --git a/ext/scintilla/delbin.bat b/ext/scintilla/delbin.bat
deleted file mode 100644
index 3636b987d..000000000
--- a/ext/scintilla/delbin.bat
+++ /dev/null
@@ -1 +0,0 @@
-del /S /Q *.a *.aps *.bsc *.dll *.dsw *.exe *.idb *.ilc *.ild *.ilf *.ilk *.ils *.lib *.map *.ncb *.obj *.o *.opt *.pdb *.plg *.res *.sbr *.tds *.exp *.tlog >NUL:
diff --git a/ext/scintilla/delcvs.bat b/ext/scintilla/delcvs.bat
deleted file mode 100644
index d3ed21ce1..000000000
--- a/ext/scintilla/delcvs.bat
+++ /dev/null
@@ -1 +0,0 @@
-del /S /Q .cvsignore
diff --git a/ext/scintilla/doc/ScintillaDoc.html b/ext/scintilla/doc/ScintillaDoc.html
index c2779a8c2..00c6b7899 100644
--- a/ext/scintilla/doc/ScintillaDoc.html
+++ b/ext/scintilla/doc/ScintillaDoc.html
@@ -82,7 +82,7 @@
 
     <h1>Scintilla Documentation</h1>
 
-    <p>Last edited 24 November 2014 NH</p>
+    <p>Last edited 10 January 2015 NH</p>
 
     <p>There is <a class="jump" href="Design.html">an overview of the internal design of
     Scintilla</a>.<br />
@@ -2577,11 +2577,15 @@ struct Sci_TextToFind {
     <b id="SCI_STYLEGETITALIC">SCI_STYLEGETITALIC(int styleNumber)</b><br />
      These messages (plus <a class="message"
     href="#SCI_STYLESETCHARACTERSET"><code>SCI_STYLESETCHARACTERSET</code></a>) set the font
-    attributes that are used to match the fonts you request to those available. The
+    attributes that are used to match the fonts you request to those available.</p>
+    <p>The
     <code>fontName</code> is a zero terminated string holding the name of a font. Under Windows,
-    only the first 32 characters of the name are used and the name is not case sensitive. For
+    only the first 32 characters of the name are used, the name is decoded as UTF-8, and the name is not case sensitive. For
     internal caching, Scintilla tracks fonts by name and does care about the casing of font names,
-    so please be consistent. On GTK+, Pango is used to display text.</p>
+    so please be consistent.
+    On GTK+, Pango is used to display text and the name is sent directly to Pango without transformation.
+    On Qt, the name is decoded as UTF-8.
+    On Cocoa, the name is decoded as MacRoman.</p>
     <p>Sizes can be set to a whole number of points with <code>SCI_STYLESETSIZE</code>
     or to a fractional point size in hundredths of a point with <code>SCI_STYLESETSIZEFRACTIONAL</code>
     by multiplying the size by 100 (<code>SC_FONT_SIZE_MULTIPLIER</code>).
@@ -7320,6 +7324,7 @@ for line = lineStart to lineEnd do SCI_ENSUREVISIBLE(line) next
      These notifications are generated when the user clicks or double clicks on
      text that is in a style with the hotspot attribute set.
     This notification can be used to link to variable definitions or web pages.
+    In the notification handler, you should avoid calling any function that modifies the current selection or caret position.
     The <code>position</code> field is set the text position of the click or
     double click and the <code>modifiers</code> field set to the key modifiers
     held down in a similar manner to <a class="message" href="#SCN_KEY">SCN_KEY</a>.
diff --git a/ext/scintilla/doc/ScintillaDownload.html b/ext/scintilla/doc/ScintillaDownload.html
index 4677dc9af..c272a48e5 100644
--- a/ext/scintilla/doc/ScintillaDownload.html
+++ b/ext/scintilla/doc/ScintillaDownload.html
@@ -25,9 +25,9 @@
     <table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
       <tr>
         <td>
-          <font size="4"> <a href="http://prdownloads.sourceforge.net/scintilla/scintilla352.zip?download">
+          <font size="4"> <a href="http://prdownloads.sourceforge.net/scintilla/scintilla353.zip?download">
 	Windows</a>&nbsp;&nbsp;
-	<a href="http://prdownloads.sourceforge.net/scintilla/scintilla352.tgz?download">
+	<a href="http://prdownloads.sourceforge.net/scintilla/scintilla353.tgz?download">
           GTK+/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -41,7 +41,7 @@
       containing very few restrictions.
     </p>
     <h3>
-       Release 3.5.2
+       Release 3.5.3
     </h3>
     <h4>
        Source Code
@@ -49,8 +49,8 @@
        The source code package contains all of the source code for Scintilla but no binary
 	executable code and is available in
        <ul>
-       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla352.zip?download">zip format</a> (1450K) commonly used on Windows</li>
-       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla352.tgz?download">tgz format</a> (1300K) commonly used on Linux and compatible operating systems</li>
+       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla353.zip?download">zip format</a> (1450K) commonly used on Windows</li>
+       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla353.tgz?download">tgz format</a> (1300K) commonly used on Linux and compatible operating systems</li>
        </ul>
        Instructions for building on both Windows and Linux are included in the readme file.
     <h4>
diff --git a/ext/scintilla/doc/ScintillaHistory.html b/ext/scintilla/doc/ScintillaHistory.html
index d1afca38d..4360b2824 100644
--- a/ext/scintilla/doc/ScintillaHistory.html
+++ b/ext/scintilla/doc/ScintillaHistory.html
@@ -463,6 +463,8 @@
       </tr><tr>
 	<td>Erik Angelin</td>
 	<td>Yusuf Ramazan Karagöz</td>
+	<td>Markus Heidelberg</td>
+	<td>Joe Mueller</td>
     </tr>
     </table>
     <p>
@@ -475,6 +477,74 @@
       </li>
     </ul>
     <h3>
+       <a href="http://prdownloads.sourceforge.net/scintilla/scite353.zip?download">Release 3.5.3</a>
+    </h3>
+    <ul>
+	<li>
+	Released 20 January 2015.
+	</li>
+	<li>
+	Support removed for Windows 95, 98, and ME.
+	</li>
+	<li>
+	Lexers added for Motorola S-Record files, Intel hex files, and Tektronix extended hex files with folding for Intel hex files.
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1091/">Feature #1091.</a>
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1093/">Feature #1093.</a>
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1095/">Feature #1095.</a>
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1096/">Feature #1096.</a>
+	</li>
+	<li>
+	C++ folder allows folding on square brackets '['.
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1087/">Feature #1087.</a>
+	</li>
+	<li>
+	Shell lexer fixes three issues with here-documents.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1672/">Bug #1672</a>.
+	</li>
+	<li>
+	Verilog lexer highlights doc comment keywords; has separate styles for input, output, and inout ports
+	(lexer.verilog.portstyling); fixes a bug in highlighting numbers; can treat upper-case identifiers as
+	keywords (lexer.verilog.allupperkeywords); and can use different styles for code that is inactive due
+	to preprocessor commands (lexer.verilog.track.preprocessor, lexer.verilog.update.preprocessor).
+	</li>
+	<li>
+	When the calltip window is taller than the Scintilla window, leave it in a
+	position that avoids overlapping the Scintilla text.
+	</li>
+	<li>
+	When a text margin is displayed, for annotation lines, use the background colour of the base line.
+	</li>
+	<li>
+	On Windows GDI, assume font names are encoded in UTF-8. This matches the Direct2D code path.
+	</li>
+	<li>
+	Fix paste for GTK+ on OS X.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1677/">Bug #1677</a>.
+	</li>
+	<li>
+	Reverted a fix on Qt where Qt 5.3 has returned to the behaviour of 4.x.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1575/">Bug #1575</a>.
+	</li>
+	<li>
+	When the mouse is on the line between margin and text changed to treat as within text.
+	This makes the PLAT_CURSES character cell platform work better.
+	</li>
+	<li>
+	Fix a crash in SciTE when the command line is just "-close:".
+	<a href="http://sourceforge.net/p/scintilla/bugs/1675/">Bug #1675</a>.
+	</li>
+	<li>
+	Fix unexpected dialog in SciTE on Windows when the command line has a quoted filename then ends with a space.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1673/">Bug #1673</a>.
+	</li>
+	<li>
+	On Windows and GTK+, use indicators for inline IME.
+	</li>
+	<li>
+	SciTE shuts down quicker when there is no user-written OnClose function and no directors are attached.
+	</li>
+    </ul>
+    <h3>
        <a href="http://prdownloads.sourceforge.net/scintilla/scite352.zip?download">Release 3.5.2</a>
     </h3>
     <ul>
@@ -498,6 +568,7 @@
 	<li>
 	ANNOTATION_INDENTED added which is similar to ANNOTATION_BOXED in terms of positioning
 	but does not show a border.
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1086/">Feature #1086.</a>
 	</li>
 	<li>
 	Allow platform overrides for drawing tab arrows, wrap markers, and line markers.
diff --git a/ext/scintilla/doc/index.html b/ext/scintilla/doc/index.html
index 89dd22c7c..900b1b661 100644
--- a/ext/scintilla/doc/index.html
+++ b/ext/scintilla/doc/index.html
@@ -9,7 +9,7 @@
     <meta name="keywords" content="Scintilla, SciTE, Editing Component, Text Editor" />
     <meta name="Description"
     content="www.scintilla.org is the home of the Scintilla editing component and SciTE text editor application." />
-    <meta name="Date.Modified" content="20141202" />
+    <meta name="Date.Modified" content="20150120" />
     <style type="text/css">
         #versionlist {
             margin: 0;
@@ -55,8 +55,8 @@
           GTK+, and OS X</font>
         </td>
         <td width="40%" align="right">
-          <font color="#FFCC99" size="3"> Release version 3.5.2<br />
-           Site last modified December 2 2014</font>
+          <font color="#FFCC99" size="3"> Release version 3.5.3<br />
+           Site last modified January 20 2015</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -71,6 +71,7 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 3.5.3 removes support for Windows 95, 98, and ME.</li>
       <li>Version 3.5.2 only supports 64-bit builds for OS X 10.7+ Cocoa. Provisional support of C++11 &lt;regex&gt;.</li>
       <li>Version 3.5.1 fixes minor bugs and includes a lexer for BibTeX.</li>
       <li>Version 3.5.0 can share space vertically so that extreme ascenders and descenders are not cut off.
diff --git a/ext/scintilla/include/Platform.h b/ext/scintilla/include/Platform.h
index 83fc9ed9e..5f2ba0d70 100644
--- a/ext/scintilla/include/Platform.h
+++ b/ext/scintilla/include/Platform.h
@@ -144,6 +144,11 @@ public:
 		return (pt.x >= left) && (pt.x <= right) &&
 			(pt.y >= top) && (pt.y <= bottom);
 	}
+	bool ContainsWholePixel(Point pt) const {
+		// Does the rectangle contain all of the pixel to left/below the point 
+		return (pt.x >= left) && ((pt.x+1) <= right) &&
+			(pt.y >= top) && ((pt.y+1) <= bottom);
+	}
 	bool Contains(PRectangle rc) const {
 		return (rc.left >= left) && (rc.right <= right) &&
 			(rc.top >= top) && (rc.bottom <= bottom);
diff --git a/ext/scintilla/include/SciLexer.h b/ext/scintilla/include/SciLexer.h
index 81c512359..e7ae4c4b7 100644
--- a/ext/scintilla/include/SciLexer.h
+++ b/ext/scintilla/include/SciLexer.h
@@ -129,6 +129,9 @@
 #define SCLEX_DMIS 114
 #define SCLEX_REGISTRY 115
 #define SCLEX_BIBTEX 116
+#define SCLEX_SREC 117
+#define SCLEX_IHEX 118
+#define SCLEX_TEHEX 119
 #define SCLEX_AUTOMATIC 1000
 #define SCE_P_DEFAULT 0
 #define SCE_P_COMMENTLINE 1
@@ -898,6 +901,11 @@
 #define SCE_V_IDENTIFIER 11
 #define SCE_V_STRINGEOL 12
 #define SCE_V_USER 19
+#define SCE_V_COMMENT_WORD 20
+#define SCE_V_INPUT 21
+#define SCE_V_OUTPUT 22
+#define SCE_V_INOUT 23
+#define SCE_V_PORT_CONNECT 24
 #define SCE_KIX_DEFAULT 0
 #define SCE_KIX_COMMENT 1
 #define SCE_KIX_STRING1 2
@@ -1741,6 +1749,25 @@
 #define SCE_BIBTEX_PARAMETER 4
 #define SCE_BIBTEX_VALUE 5
 #define SCE_BIBTEX_COMMENT 6
+#define SCE_HEX_DEFAULT 0
+#define SCE_HEX_RECSTART 1
+#define SCE_HEX_RECTYPE 2
+#define SCE_HEX_RECTYPE_UNKNOWN 3
+#define SCE_HEX_BYTECOUNT 4
+#define SCE_HEX_BYTECOUNT_WRONG 5
+#define SCE_HEX_NOADDRESS 6
+#define SCE_HEX_DATAADDRESS 7
+#define SCE_HEX_RECCOUNT 8
+#define SCE_HEX_STARTADDRESS 9
+#define SCE_HEX_ADDRESSFIELD_UNKNOWN 10
+#define SCE_HEX_EXTENDEDADDRESS 11
+#define SCE_HEX_DATA_ODD 12
+#define SCE_HEX_DATA_EVEN 13
+#define SCE_HEX_DATA_UNKNOWN 14
+#define SCE_HEX_DATA_EMPTY 15
+#define SCE_HEX_CHECKSUM 16
+#define SCE_HEX_CHECKSUM_WRONG 17
+#define SCE_HEX_GARBAGE 18
 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */
 
 #endif
diff --git a/ext/scintilla/include/Scintilla.h b/ext/scintilla/include/Scintilla.h
index 3ef70f23c..3abc72bc6 100644
--- a/ext/scintilla/include/Scintilla.h
+++ b/ext/scintilla/include/Scintilla.h
@@ -1036,7 +1036,6 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCN_HOTSPOTRELEASECLICK 2027
 #define SCN_FOCUSIN 2028
 #define SCN_FOCUSOUT 2029
-#define SCN_GETBKCOLOR 5000
 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */
 
 /* These structures are defined to be exactly the same shape as the Win32
diff --git a/ext/scintilla/include/Scintilla.iface b/ext/scintilla/include/Scintilla.iface
index d49b37554..b16771b09 100644
--- a/ext/scintilla/include/Scintilla.iface
+++ b/ext/scintilla/include/Scintilla.iface
@@ -2719,6 +2719,9 @@ val SCLEX_AS=113
 val SCLEX_DMIS=114
 val SCLEX_REGISTRY=115
 val SCLEX_BIBTEX=116
+val SCLEX_SREC=117
+val SCLEX_IHEX=118
+val SCLEX_TEHEX=119
 
 # When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
 # value assigned in sequence from SCLEX_AUTOMATIC+1.
@@ -3599,6 +3602,11 @@ val SCE_V_OPERATOR=10
 val SCE_V_IDENTIFIER=11
 val SCE_V_STRINGEOL=12
 val SCE_V_USER=19
+val SCE_V_COMMENT_WORD=20
+val SCE_V_INPUT=21
+val SCE_V_OUTPUT=22
+val SCE_V_INOUT=23
+val SCE_V_PORT_CONNECT=24
 # Lexical states for SCLEX_KIX
 lex Kix=SCLEX_KIX SCE_KIX_
 val SCE_KIX_DEFAULT=0
@@ -4542,6 +4550,31 @@ val SCE_BIBTEX_KEY=3
 val SCE_BIBTEX_PARAMETER=4
 val SCE_BIBTEX_VALUE=5
 val SCE_BIBTEX_COMMENT=6
+# Lexical state for SCLEX_SREC
+lex Srec=SCLEX_SREC SCE_HEX_
+val SCE_HEX_DEFAULT=0
+val SCE_HEX_RECSTART=1
+val SCE_HEX_RECTYPE=2
+val SCE_HEX_RECTYPE_UNKNOWN=3
+val SCE_HEX_BYTECOUNT=4
+val SCE_HEX_BYTECOUNT_WRONG=5
+val SCE_HEX_NOADDRESS=6
+val SCE_HEX_DATAADDRESS=7
+val SCE_HEX_RECCOUNT=8
+val SCE_HEX_STARTADDRESS=9
+val SCE_HEX_ADDRESSFIELD_UNKNOWN=10
+val SCE_HEX_EXTENDEDADDRESS=11
+val SCE_HEX_DATA_ODD=12
+val SCE_HEX_DATA_EVEN=13
+val SCE_HEX_DATA_UNKNOWN=14
+val SCE_HEX_DATA_EMPTY=15
+val SCE_HEX_CHECKSUM=16
+val SCE_HEX_CHECKSUM_WRONG=17
+val SCE_HEX_GARBAGE=18
+# Lexical state for SCLEX_IHEX (shared with Srec)
+lex IHex=SCLEX_IHEX SCE_HEX_
+# Lexical state for SCLEX_TEHEX (shared with Srec)
+lex TEHex=SCLEX_TEHEX SCE_HEX_
 
 # Events
 
diff --git a/ext/scintilla/lexers/LexBash.cxx b/ext/scintilla/lexers/LexBash.cxx
index cfc214a90..b495575d8 100644
--- a/ext/scintilla/lexers/LexBash.cxx
+++ b/ext/scintilla/lexers/LexBash.cxx
@@ -419,8 +419,6 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 						sc.Forward();
 						HereDoc.Quoted = true;
 						HereDoc.State = 1;
-					} else if (!HereDoc.Indent && sc.chNext == '-') {	// <<- indent case
-						HereDoc.Indent = true;
 					} else if (setHereDoc.Contains(sc.chNext)) {
 						// an unquoted here-doc delimiter, no special handling
 						// TODO check what exactly bash considers part of the delim
@@ -469,7 +467,7 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 				if (sc.atLineStart) {
 					sc.SetState(SCE_SH_HERE_Q);
 					int prefixws = 0;
-					while (IsASpace(sc.ch) && !sc.atLineEnd) {	// whitespace prefix
+					while (sc.ch == '\t' && !sc.atLineEnd) {	// tabulation prefix
 						sc.Forward();
 						prefixws++;
 					}
@@ -481,7 +479,8 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 					char s[HERE_DELIM_MAX];
 					sc.GetCurrent(s, sizeof(s));
 					if (sc.LengthCurrent() == 0) {  // '' or "" delimiters
-						if (prefixws == 0 && HereDoc.Quoted && HereDoc.DelimiterLength == 0)
+						if ((prefixws == 0 || HereDoc.Indent) &&
+							HereDoc.Quoted && HereDoc.DelimiterLength == 0)
 							sc.SetState(SCE_SH_DEFAULT);
 						break;
 					}
@@ -672,7 +671,12 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 			} else if (sc.Match('<', '<')) {
 				sc.SetState(SCE_SH_HERE_DELIM);
 				HereDoc.State = 0;
-				HereDoc.Indent = false;
+				if (sc.GetRelative(2) == '-') {	// <<- indent case
+					HereDoc.Indent = true;
+					sc.Forward();
+				} else {
+					HereDoc.Indent = false;
+				}
 			} else if (sc.ch == '-'	&&	// one-char file test operators
 					   setSingleCharOp.Contains(sc.chNext) &&
 					   !setWord.Contains(sc.GetRelative(2)) &&
diff --git a/ext/scintilla/lexers/LexCPP.cxx b/ext/scintilla/lexers/LexCPP.cxx
index f686fc3ae..d0aba67a4 100644
--- a/ext/scintilla/lexers/LexCPP.cxx
+++ b/ext/scintilla/lexers/LexCPP.cxx
@@ -1344,14 +1344,14 @@ void SCI_METHOD LexerCPP::Fold(unsigned int startPos, int length, int initStyle,
 			}
 		}
 		if (options.foldSyntaxBased && (style == SCE_C_OPERATOR)) {
-			if (ch == '{') {
+			if (ch == '{' || ch == '[') {
 				// Measure the minimum before a '{' to allow
 				// folding on "} else {"
 				if (levelMinCurrent > levelNext) {
 					levelMinCurrent = levelNext;
 				}
 				levelNext++;
-			} else if (ch == '}') {
+			} else if (ch == '}' || ch == ']') {
 				levelNext--;
 			}
 		}
diff --git a/ext/scintilla/lexers/LexHex.cxx b/ext/scintilla/lexers/LexHex.cxx
new file mode 100644
index 000000000..2c43bdd4a
--- /dev/null
+++ b/ext/scintilla/lexers/LexHex.cxx
@@ -0,0 +1,1045 @@
+// Scintilla source code edit control
+/** @file LexHex.cxx
+ ** Lexers for Motorola S-Record, Intel HEX and Tektronix extended HEX.
+ **
+ ** Written by Markus Heidelberg
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+/*
+ *  Motorola S-Record
+ * ===============================
+ *
+ * Each record (line) is built as follows:
+ *
+ *    field       digits          states
+ *
+ *  +----------+
+ *  | start    |  1 ('S')         SCE_HEX_RECSTART
+ *  +----------+
+ *  | type     |  1               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
+ *  +----------+
+ *  | count    |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
+ *  +----------+
+ *  | address  |  4/6/8           SCE_HEX_NOADDRESS, SCE_HEX_DATAADDRESS, SCE_HEX_RECCOUNT, SCE_HEX_STARTADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
+ *  +----------+
+ *  | data     |  0..504/502/500  SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN, SCE_HEX_DATA_EMPTY, (SCE_HEX_DATA_UNKNOWN)
+ *  +----------+
+ *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
+ *  +----------+
+ *
+ *
+ *  Intel HEX
+ * ===============================
+ *
+ * Each record (line) is built as follows:
+ *
+ *    field       digits          states
+ *
+ *  +----------+
+ *  | start    |  1 (':')         SCE_HEX_RECSTART
+ *  +----------+
+ *  | count    |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
+ *  +----------+
+ *  | address  |  4               SCE_HEX_NOADDRESS, SCE_HEX_DATAADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
+ *  +----------+
+ *  | type     |  2               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
+ *  +----------+
+ *  | data     |  0..510          SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN, SCE_HEX_DATA_EMPTY, SCE_HEX_EXTENDEDADDRESS, SCE_HEX_STARTADDRESS, (SCE_HEX_DATA_UNKNOWN)
+ *  +----------+
+ *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
+ *  +----------+
+ *
+ *
+ * Folding:
+ *
+ *   Data records (type 0x00), which follow an extended address record (type
+ *   0x02 or 0x04), can be folded. The extended address record is the fold
+ *   point at fold level 0, the corresponding data records are set to level 1.
+ *
+ *   Any record, which is not a data record, sets the fold level back to 0.
+ *   Any line, which is not a record (blank lines and lines starting with a
+ *   character other than ':'), leaves the fold level unchanged.
+ *
+ *
+ *  Tektronix extended HEX
+ * ===============================
+ *
+ * Each record (line) is built as follows:
+ *
+ *    field       digits          states
+ *
+ *  +----------+
+ *  | start    |  1 ('%')         SCE_HEX_RECSTART
+ *  +----------+
+ *  | length   |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
+ *  +----------+
+ *  | type     |  1               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
+ *  +----------+
+ *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
+ *  +----------+
+ *  | address  |  9               SCE_HEX_DATAADDRESS, SCE_HEX_STARTADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
+ *  +----------+
+ *  | data     |  0..241          SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN
+ *  +----------+
+ *
+ *
+ *  General notes for all lexers
+ * ===============================
+ *
+ * - Depending on where the helper functions are invoked, some of them have to
+ *   read beyond the current position. In case of malformed data (record too
+ *   short), it has to be ensured that this either does not have bad influence
+ *   or will be captured deliberately.
+ *
+ * - States in parentheses in the upper format descriptions indicate that they
+ *   should not appear in a valid hex file.
+ *
+ * - State SCE_HEX_GARBAGE means garbage data after the intended end of the
+ *   record, the line is too long then. This state is used in all lexers.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+#ifdef SCI_NAMESPACE
+using namespace Scintilla;
+#endif
+
+// prototypes for general helper functions
+static inline bool IsNewline(const int ch);
+static int GetHexaNibble(char hd);
+static int GetHexaChar(char hd1, char hd2);
+static int GetHexaChar(unsigned int pos, Accessor &styler);
+static bool ForwardWithinLine(StyleContext &sc, int nb = 1);
+static bool PosInSameRecord(unsigned int pos1, unsigned int pos2, Accessor &styler);
+static int CountByteCount(unsigned int startPos, int uncountedDigits, Accessor &styler);
+static int CalcChecksum(unsigned int startPos, int cnt, bool twosCompl, Accessor &styler);
+
+// prototypes for file format specific helper functions
+static unsigned int GetSrecRecStartPosition(unsigned int pos, Accessor &styler);
+static int GetSrecByteCount(unsigned int recStartPos, Accessor &styler);
+static int CountSrecByteCount(unsigned int recStartPos, Accessor &styler);
+static int GetSrecAddressFieldSize(unsigned int recStartPos, Accessor &styler);
+static int GetSrecAddressFieldType(unsigned int recStartPos, Accessor &styler);
+static int GetSrecDataFieldType(unsigned int recStartPos, Accessor &styler);
+static int GetSrecRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler);
+static int GetSrecChecksum(unsigned int recStartPos, Accessor &styler);
+static int CalcSrecChecksum(unsigned int recStartPos, Accessor &styler);
+
+static unsigned int GetIHexRecStartPosition(unsigned int pos, Accessor &styler);
+static int GetIHexByteCount(unsigned int recStartPos, Accessor &styler);
+static int CountIHexByteCount(unsigned int recStartPos, Accessor &styler);
+static int GetIHexAddressFieldType(unsigned int recStartPos, Accessor &styler);
+static int GetIHexDataFieldType(unsigned int recStartPos, Accessor &styler);
+static int GetIHexRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler);
+static int GetIHexChecksum(unsigned int recStartPos, Accessor &styler);
+static int CalcIHexChecksum(unsigned int recStartPos, Accessor &styler);
+
+static int GetTEHexDigitCount(unsigned int recStartPos, Accessor &styler);
+static int CountTEHexDigitCount(unsigned int recStartPos, Accessor &styler);
+static int GetTEHexAddressFieldType(unsigned int recStartPos, Accessor &styler);
+static int GetTEHexChecksum(unsigned int recStartPos, Accessor &styler);
+static int CalcTEHexChecksum(unsigned int recStartPos, Accessor &styler);
+
+static inline bool IsNewline(const int ch)
+{
+    return (ch == '\n' || ch == '\r');
+}
+
+static int GetHexaNibble(char hd)
+{
+	int hexValue = 0;
+
+	if (hd >= '0' && hd <= '9') {
+		hexValue += hd - '0';
+	} else if (hd >= 'A' && hd <= 'F') {
+		hexValue += hd - 'A' + 10;
+	} else if (hd >= 'a' && hd <= 'f') {
+		hexValue += hd - 'a' + 10;
+	} else {
+		return -1;
+	}
+
+	return hexValue;
+}
+
+static int GetHexaChar(char hd1, char hd2)
+{
+	int hexValue = 0;
+
+	if (hd1 >= '0' && hd1 <= '9') {
+		hexValue += 16 * (hd1 - '0');
+	} else if (hd1 >= 'A' && hd1 <= 'F') {
+		hexValue += 16 * (hd1 - 'A' + 10);
+	} else if (hd1 >= 'a' && hd1 <= 'f') {
+		hexValue += 16 * (hd1 - 'a' + 10);
+	} else {
+		return -1;
+	}
+
+	if (hd2 >= '0' && hd2 <= '9') {
+		hexValue += hd2 - '0';
+	} else if (hd2 >= 'A' && hd2 <= 'F') {
+		hexValue += hd2 - 'A' + 10;
+	} else if (hd2 >= 'a' && hd2 <= 'f') {
+		hexValue += hd2 - 'a' + 10;
+	} else {
+		return -1;
+	}
+
+	return hexValue;
+}
+
+static int GetHexaChar(unsigned int pos, Accessor &styler)
+{
+	char highNibble, lowNibble;
+
+	highNibble = styler.SafeGetCharAt(pos);
+	lowNibble = styler.SafeGetCharAt(pos + 1);
+
+	return GetHexaChar(highNibble, lowNibble);
+}
+
+// Forward <nb> characters, but abort (and return false) if hitting the line
+// end. Return true if forwarding within the line was possible.
+// Avoids influence on highlighting of the subsequent line if the current line
+// is malformed (too short).
+static bool ForwardWithinLine(StyleContext &sc, int nb)
+{
+	for (int i = 0; i < nb; i++) {
+		if (sc.atLineEnd) {
+			// line is too short
+			sc.SetState(SCE_HEX_DEFAULT);
+			sc.Forward();
+			return false;
+		} else {
+			sc.Forward();
+		}
+	}
+
+	return true;
+}
+
+// Checks whether the given positions are in the same record.
+static bool PosInSameRecord(unsigned int pos1, unsigned int pos2, Accessor &styler)
+{
+	return styler.GetLine(pos1) == styler.GetLine(pos2);
+}
+
+// Count the number of digit pairs from <startPos> till end of record, ignoring
+// <uncountedDigits> digits.
+// If the record is too short, a negative count may be returned.
+static int CountByteCount(unsigned int startPos, int uncountedDigits, Accessor &styler)
+{
+	int cnt;
+	unsigned int pos;
+
+	pos = startPos;
+
+	while (!IsNewline(styler.SafeGetCharAt(pos, '\n'))) {
+		pos++;
+	}
+
+	// number of digits in this line minus number of digits of uncounted fields
+	cnt = static_cast<int>(pos - startPos) - uncountedDigits;
+
+	// Prepare round up if odd (digit pair incomplete), this way the byte
+	// count is considered to be valid if the checksum is incomplete.
+	if (cnt >= 0) {
+		cnt++;
+	}
+
+	// digit pairs
+	cnt /= 2;
+
+	return cnt;
+}
+
+// Calculate the checksum of the record.
+// <startPos> is the position of the first character of the starting digit
+// pair, <cnt> is the number of digit pairs.
+static int CalcChecksum(unsigned int startPos, int cnt, bool twosCompl, Accessor &styler)
+{
+	int cs = 0;
+
+	for (unsigned int pos = startPos; pos < startPos + cnt; pos += 2) {
+		int val = GetHexaChar(pos, styler);
+
+		if (val < 0) {
+			return val;
+		}
+
+		// overflow does not matter
+		cs += val;
+	}
+
+	if (twosCompl) {
+		// low byte of two's complement
+		return -cs & 0xFF;
+	} else {
+		// low byte of one's complement
+		return ~cs & 0xFF;
+	}
+}
+
+// Get the position of the record "start" field (first character in line) in
+// the record around position <pos>.
+static unsigned int GetSrecRecStartPosition(unsigned int pos, Accessor &styler)
+{
+	while (styler.SafeGetCharAt(pos) != 'S') {
+		pos--;
+	}
+
+	return pos;
+}
+
+// Get the value of the "byte count" field, it counts the number of bytes in
+// the subsequent fields ("address", "data" and "checksum" fields).
+static int GetSrecByteCount(unsigned int recStartPos, Accessor &styler)
+{
+	int val;
+
+	val = GetHexaChar(recStartPos + 2, styler);
+	if (val < 0) {
+	       val = 0;
+	}
+
+	return val;
+}
+
+// Count the number of digit pairs for the "address", "data" and "checksum"
+// fields in this record. Has to be equal to the "byte count" field value.
+// If the record is too short, a negative count may be returned.
+static int CountSrecByteCount(unsigned int recStartPos, Accessor &styler)
+{
+	return CountByteCount(recStartPos, 4, styler);
+}
+
+// Get the size of the "address" field.
+static int GetSrecAddressFieldSize(unsigned int recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '0':
+		case '1':
+		case '5':
+		case '9':
+			return 2; // 16 bit
+
+		case '2':
+		case '6':
+		case '8':
+			return 3; // 24 bit
+
+		case '3':
+		case '7':
+			return 4; // 32 bit
+
+		default:
+			return 0;
+	}
+}
+
+// Get the type of the "address" field content.
+static int GetSrecAddressFieldType(unsigned int recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '0':
+			return SCE_HEX_NOADDRESS;
+
+		case '1':
+		case '2':
+		case '3':
+			return SCE_HEX_DATAADDRESS;
+
+		case '5':
+		case '6':
+			return SCE_HEX_RECCOUNT;
+
+		case '7':
+		case '8':
+		case '9':
+			return SCE_HEX_STARTADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+}
+
+// Get the type of the "data" field content.
+static int GetSrecDataFieldType(unsigned int recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+			return SCE_HEX_DATA_ODD;
+
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			return SCE_HEX_DATA_EMPTY;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_DATA_UNKNOWN;
+	}
+}
+
+// Get the required size of the "data" field. Useless for block header and
+// ordinary data records (type S0, S1, S2, S3), return the value calculated
+// from the "byte count" and "address field" size in this case.
+static int GetSrecRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			return 0;
+
+		default:
+			return GetSrecByteCount(recStartPos, styler)
+				- GetSrecAddressFieldSize(recStartPos, styler)
+				- 1; // -1 for checksum field
+	}
+}
+
+// Get the value of the "checksum" field.
+static int GetSrecChecksum(unsigned int recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetSrecByteCount(recStartPos, styler);
+
+	return GetHexaChar(recStartPos + 2 + byteCount * 2, styler);
+}
+
+// Calculate the checksum of the record.
+static int CalcSrecChecksum(unsigned int recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetSrecByteCount(recStartPos, styler);
+
+	// sum over "byte count", "address" and "data" fields (6..510 digits)
+	return CalcChecksum(recStartPos + 2, byteCount * 2, false, styler);
+}
+
+// Get the position of the record "start" field (first character in line) in
+// the record around position <pos>.
+static unsigned int GetIHexRecStartPosition(unsigned int pos, Accessor &styler)
+{
+	while (styler.SafeGetCharAt(pos) != ':') {
+		pos--;
+	}
+
+	return pos;
+}
+
+// Get the value of the "byte count" field, it counts the number of bytes in
+// the "data" field.
+static int GetIHexByteCount(unsigned int recStartPos, Accessor &styler)
+{
+	int val;
+
+	val = GetHexaChar(recStartPos + 1, styler);
+	if (val < 0) {
+	       val = 0;
+	}
+
+	return val;
+}
+
+// Count the number of digit pairs for the "data" field in this record. Has to
+// be equal to the "byte count" field value.
+// If the record is too short, a negative count may be returned.
+static int CountIHexByteCount(unsigned int recStartPos, Accessor &styler)
+{
+	return CountByteCount(recStartPos, 11, styler);
+}
+
+// Get the type of the "address" field content.
+static int GetIHexAddressFieldType(unsigned int recStartPos, Accessor &styler)
+{
+	if (!PosInSameRecord(recStartPos, recStartPos + 7, styler)) {
+		// malformed (record too short)
+		// type cannot be determined
+		return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+
+	switch (GetHexaChar(recStartPos + 7, styler)) {
+		case 0x00:
+			return SCE_HEX_DATAADDRESS;
+
+		case 0x01:
+		case 0x02:
+		case 0x03:
+		case 0x04:
+		case 0x05:
+			return SCE_HEX_NOADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+}
+
+// Get the type of the "data" field content.
+static int GetIHexDataFieldType(unsigned int recStartPos, Accessor &styler)
+{
+	switch (GetHexaChar(recStartPos + 7, styler)) {
+		case 0x00:
+			return SCE_HEX_DATA_ODD;
+
+		case 0x01:
+			return SCE_HEX_DATA_EMPTY;
+
+		case 0x02:
+		case 0x04:
+			return SCE_HEX_EXTENDEDADDRESS;
+
+		case 0x03:
+		case 0x05:
+			return SCE_HEX_STARTADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_DATA_UNKNOWN;
+	}
+}
+
+// Get the required size of the "data" field. Useless for an ordinary data
+// record (type 00), return the "byte count" in this case.
+static int GetIHexRequiredDataFieldSize(unsigned int recStartPos, Accessor &styler)
+{
+	switch (GetHexaChar(recStartPos + 7, styler)) {
+		case 0x01:
+			return 0;
+
+		case 0x02:
+		case 0x04:
+			return 2;
+
+		case 0x03:
+		case 0x05:
+			return 4;
+
+		default:
+			return GetIHexByteCount(recStartPos, styler);
+	}
+}
+
+// Get the value of the "checksum" field.
+static int GetIHexChecksum(unsigned int recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetIHexByteCount(recStartPos, styler);
+
+	return GetHexaChar(recStartPos + 9 + byteCount * 2, styler);
+}
+
+// Calculate the checksum of the record.
+static int CalcIHexChecksum(unsigned int recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetIHexByteCount(recStartPos, styler);
+
+	// sum over "byte count", "address", "type" and "data" fields (8..518 digits)
+	return CalcChecksum(recStartPos + 1, 8 + byteCount * 2, true, styler);
+}
+
+
+// Get the value of the "record length" field, it counts the number of digits in
+// the record excluding the percent.
+static int GetTEHexDigitCount(unsigned int recStartPos, Accessor &styler)
+{
+	int val = GetHexaChar(recStartPos + 1, styler);
+	if (val < 0)
+	       val = 0;
+
+	return val;
+}
+
+// Count the number of digits in this record. Has to
+// be equal to the "record length" field value.
+static int CountTEHexDigitCount(unsigned int recStartPos, Accessor &styler)
+{
+	unsigned int pos;
+
+	pos = recStartPos+1;
+
+	while (!IsNewline(styler.SafeGetCharAt(pos, '\n'))) {
+		pos++;
+	}
+
+	return static_cast<int>(pos - (recStartPos+1));
+}
+
+// Get the type of the "address" field content.
+static int GetTEHexAddressFieldType(unsigned int recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 3)) {
+		case '6':
+			return SCE_HEX_DATAADDRESS;
+
+		case '8':
+			return SCE_HEX_STARTADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+}
+
+// Get the value of the "checksum" field.
+static int GetTEHexChecksum(unsigned int recStartPos, Accessor &styler)
+{
+	return GetHexaChar(recStartPos+4, styler);
+}
+
+// Calculate the checksum of the record (excluding the checksum field).
+static int CalcTEHexChecksum(unsigned int recStartPos, Accessor &styler)
+{
+	unsigned int pos = recStartPos +1;
+	unsigned int length = GetTEHexDigitCount(recStartPos, styler);
+
+	int cs = GetHexaNibble(styler.SafeGetCharAt(pos++));//length
+	cs += GetHexaNibble(styler.SafeGetCharAt(pos++));//length
+
+	cs += GetHexaNibble(styler.SafeGetCharAt(pos++));//type
+
+	pos += 2;// jump over CS field
+
+	for (; pos <= recStartPos + length; ++pos) {
+		int val = GetHexaNibble(styler.SafeGetCharAt(pos));
+
+		if (val < 0) {
+			return val;
+		}
+
+		// overflow does not matter
+		cs += val;
+	}
+
+	// low byte
+	return cs & 0xFF;
+
+}
+
+static void ColouriseSrecDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	while (sc.More()) {
+		unsigned int recStartPos;
+		int byteCount, reqByteCount, addrFieldSize, addrFieldType, dataFieldSize, dataFieldType;
+		int cs1, cs2;
+
+		switch (sc.state) {
+			case SCE_HEX_DEFAULT:
+				if (sc.atLineStart && sc.Match('S')) {
+					sc.SetState(SCE_HEX_RECSTART);
+				}
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECSTART:
+				recStartPos = sc.currentPos - 1;
+				addrFieldType = GetSrecAddressFieldType(recStartPos, styler);
+
+				if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
+					sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
+				} else {
+					sc.SetState(SCE_HEX_RECTYPE);
+				}
+
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECTYPE:
+			case SCE_HEX_RECTYPE_UNKNOWN:
+				recStartPos = sc.currentPos - 2;
+				byteCount = GetSrecByteCount(recStartPos, styler);
+				reqByteCount = GetSrecAddressFieldSize(recStartPos, styler)
+						+ GetSrecRequiredDataFieldSize(recStartPos, styler)
+						+ 1; // +1 for checksum field
+
+				if (byteCount == CountSrecByteCount(recStartPos, styler)
+						&& byteCount == reqByteCount) {
+					sc.SetState(SCE_HEX_BYTECOUNT);
+				} else {
+					sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_BYTECOUNT:
+			case SCE_HEX_BYTECOUNT_WRONG:
+				recStartPos = sc.currentPos - 4;
+				addrFieldSize = GetSrecAddressFieldSize(recStartPos, styler);
+				addrFieldType = GetSrecAddressFieldType(recStartPos, styler);
+
+				sc.SetState(addrFieldType);
+				ForwardWithinLine(sc, addrFieldSize * 2);
+				break;
+
+			case SCE_HEX_NOADDRESS:
+			case SCE_HEX_DATAADDRESS:
+			case SCE_HEX_RECCOUNT:
+			case SCE_HEX_STARTADDRESS:
+			case SCE_HEX_ADDRESSFIELD_UNKNOWN:
+				recStartPos = GetSrecRecStartPosition(sc.currentPos, styler);
+				dataFieldType = GetSrecDataFieldType(recStartPos, styler);
+
+				// Using the required size here if possible has the effect that the
+				// checksum is highlighted at a fixed position after this field for
+				// specific record types, independent on the "byte count" value.
+				dataFieldSize = GetSrecRequiredDataFieldSize(recStartPos, styler);
+
+				sc.SetState(dataFieldType);
+
+				if (dataFieldType == SCE_HEX_DATA_ODD) {
+					for (int i = 0; i < dataFieldSize * 2; i++) {
+						if ((i & 0x3) == 0) {
+							sc.SetState(SCE_HEX_DATA_ODD);
+						} else if ((i & 0x3) == 2) {
+							sc.SetState(SCE_HEX_DATA_EVEN);
+						}
+
+						if (!ForwardWithinLine(sc)) {
+							break;
+						}
+					}
+				} else {
+					ForwardWithinLine(sc, dataFieldSize * 2);
+				}
+				break;
+
+			case SCE_HEX_DATA_ODD:
+			case SCE_HEX_DATA_EVEN:
+			case SCE_HEX_DATA_EMPTY:
+			case SCE_HEX_DATA_UNKNOWN:
+				recStartPos = GetSrecRecStartPosition(sc.currentPos, styler);
+				cs1 = CalcSrecChecksum(recStartPos, styler);
+				cs2 = GetSrecChecksum(recStartPos, styler);
+
+				if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
+					sc.SetState(SCE_HEX_CHECKSUM_WRONG);
+				} else {
+					sc.SetState(SCE_HEX_CHECKSUM);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_CHECKSUM:
+			case SCE_HEX_CHECKSUM_WRONG:
+			case SCE_HEX_GARBAGE:
+				// record finished or line too long
+				sc.SetState(SCE_HEX_GARBAGE);
+				ForwardWithinLine(sc);
+				break;
+
+			default:
+				// prevent endless loop in faulty state
+				sc.SetState(SCE_HEX_DEFAULT);
+				break;
+		}
+	}
+	sc.Complete();
+}
+
+static void ColouriseIHexDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	while (sc.More()) {
+		unsigned int recStartPos;
+		int byteCount, addrFieldType, dataFieldSize, dataFieldType;
+		int cs1, cs2;
+
+		switch (sc.state) {
+			case SCE_HEX_DEFAULT:
+				if (sc.atLineStart && sc.Match(':')) {
+					sc.SetState(SCE_HEX_RECSTART);
+				}
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECSTART:
+				recStartPos = sc.currentPos - 1;
+				byteCount = GetIHexByteCount(recStartPos, styler);
+				dataFieldSize = GetIHexRequiredDataFieldSize(recStartPos, styler);
+
+				if (byteCount == CountIHexByteCount(recStartPos, styler)
+						&& byteCount == dataFieldSize) {
+					sc.SetState(SCE_HEX_BYTECOUNT);
+				} else {
+					sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_BYTECOUNT:
+			case SCE_HEX_BYTECOUNT_WRONG:
+				recStartPos = sc.currentPos - 3;
+				addrFieldType = GetIHexAddressFieldType(recStartPos, styler);
+
+				sc.SetState(addrFieldType);
+				ForwardWithinLine(sc, 4);
+				break;
+
+			case SCE_HEX_NOADDRESS:
+			case SCE_HEX_DATAADDRESS:
+			case SCE_HEX_ADDRESSFIELD_UNKNOWN:
+				recStartPos = sc.currentPos - 7;
+				addrFieldType = GetIHexAddressFieldType(recStartPos, styler);
+
+				if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
+					sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
+				} else {
+					sc.SetState(SCE_HEX_RECTYPE);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_RECTYPE:
+			case SCE_HEX_RECTYPE_UNKNOWN:
+				recStartPos = sc.currentPos - 9;
+				dataFieldType = GetIHexDataFieldType(recStartPos, styler);
+
+				// Using the required size here if possible has the effect that the
+				// checksum is highlighted at a fixed position after this field for
+				// specific record types, independent on the "byte count" value.
+				dataFieldSize = GetIHexRequiredDataFieldSize(recStartPos, styler);
+
+				sc.SetState(dataFieldType);
+
+				if (dataFieldType == SCE_HEX_DATA_ODD) {
+					for (int i = 0; i < dataFieldSize * 2; i++) {
+						if ((i & 0x3) == 0) {
+							sc.SetState(SCE_HEX_DATA_ODD);
+						} else if ((i & 0x3) == 2) {
+							sc.SetState(SCE_HEX_DATA_EVEN);
+						}
+
+						if (!ForwardWithinLine(sc)) {
+							break;
+						}
+					}
+				} else {
+					ForwardWithinLine(sc, dataFieldSize * 2);
+				}
+				break;
+
+			case SCE_HEX_DATA_ODD:
+			case SCE_HEX_DATA_EVEN:
+			case SCE_HEX_DATA_EMPTY:
+			case SCE_HEX_EXTENDEDADDRESS:
+			case SCE_HEX_STARTADDRESS:
+			case SCE_HEX_DATA_UNKNOWN:
+				recStartPos = GetIHexRecStartPosition(sc.currentPos, styler);
+				cs1 = CalcIHexChecksum(recStartPos, styler);
+				cs2 = GetIHexChecksum(recStartPos, styler);
+
+				if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
+					sc.SetState(SCE_HEX_CHECKSUM_WRONG);
+				} else {
+					sc.SetState(SCE_HEX_CHECKSUM);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_CHECKSUM:
+			case SCE_HEX_CHECKSUM_WRONG:
+			case SCE_HEX_GARBAGE:
+				// record finished or line too long
+				sc.SetState(SCE_HEX_GARBAGE);
+				ForwardWithinLine(sc);
+				break;
+
+			default:
+				// prevent endless loop in faulty state
+				sc.SetState(SCE_HEX_DEFAULT);
+				break;
+		}
+	}
+	sc.Complete();
+}
+
+static void FoldIHexDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
+{
+	unsigned int endPos = startPos + length;
+
+	int lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent - 1);
+
+	unsigned int lineStartNext = styler.LineStart(lineCurrent + 1);
+	int levelNext = SC_FOLDLEVELBASE; // default if no specific line found
+
+	for (unsigned int i = startPos; i < endPos; i++) {
+		bool atEOL = i == (lineStartNext - 1);
+		int style = styler.StyleAt(i);
+
+		// search for specific lines
+		if (style == SCE_HEX_EXTENDEDADDRESS) {
+			// extended addres record
+			levelNext = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
+		} else if (style == SCE_HEX_DATAADDRESS
+			|| (style == SCE_HEX_DEFAULT
+				&& i == (unsigned int)styler.LineStart(lineCurrent))) {
+			// data record or no record start code at all
+			if (levelCurrent & SC_FOLDLEVELHEADERFLAG) {
+				levelNext = SC_FOLDLEVELBASE + 1;
+			} else {
+				// continue level 0 or 1, no fold point
+				levelNext = levelCurrent;
+			}
+		}
+
+		if (atEOL || (i == endPos - 1)) {
+			styler.SetLevel(lineCurrent, levelNext);
+
+			lineCurrent++;
+			lineStartNext = styler.LineStart(lineCurrent + 1);
+			levelCurrent = levelNext;
+			levelNext = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+static void ColouriseTEHexDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	while (sc.More()) {
+		unsigned int recStartPos;
+		int digitCount, addrFieldType;
+		int cs1, cs2;
+
+		switch (sc.state) {
+			case SCE_HEX_DEFAULT:
+				if (sc.atLineStart && sc.Match('%')) {
+					sc.SetState(SCE_HEX_RECSTART);
+				}
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECSTART:
+
+				recStartPos = sc.currentPos - 1;
+
+				if (GetTEHexDigitCount(recStartPos, styler) == CountTEHexDigitCount(recStartPos, styler)) {
+					sc.SetState(SCE_HEX_BYTECOUNT);
+				} else {
+					sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_BYTECOUNT:
+			case SCE_HEX_BYTECOUNT_WRONG:
+				recStartPos = sc.currentPos - 3;
+				addrFieldType = GetTEHexAddressFieldType(recStartPos, styler);
+
+				if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
+					sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
+				} else {
+					sc.SetState(SCE_HEX_RECTYPE);
+				}
+
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECTYPE:
+			case SCE_HEX_RECTYPE_UNKNOWN:
+				recStartPos = sc.currentPos - 4;
+				cs1 = CalcTEHexChecksum(recStartPos, styler);
+				cs2 = GetTEHexChecksum(recStartPos, styler);
+
+				if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
+					sc.SetState(SCE_HEX_CHECKSUM_WRONG);
+				} else {
+					sc.SetState(SCE_HEX_CHECKSUM);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+
+			case SCE_HEX_CHECKSUM:
+			case SCE_HEX_CHECKSUM_WRONG:
+				recStartPos = sc.currentPos - 6;
+				addrFieldType = GetTEHexAddressFieldType(recStartPos, styler);
+
+				sc.SetState(addrFieldType);
+				ForwardWithinLine(sc, 9);
+				break;
+
+			case SCE_HEX_DATAADDRESS:
+			case SCE_HEX_STARTADDRESS:
+			case SCE_HEX_ADDRESSFIELD_UNKNOWN:
+				recStartPos = sc.currentPos - 15;
+				digitCount = GetTEHexDigitCount(recStartPos, styler) - 14;
+
+				sc.SetState(SCE_HEX_DATA_ODD);
+
+				for (int i = 0; i < digitCount; i++) {
+					if ((i & 0x3) == 0) {
+						sc.SetState(SCE_HEX_DATA_ODD);
+					} else if ((i & 0x3) == 2) {
+						sc.SetState(SCE_HEX_DATA_EVEN);
+					}
+
+					if (!ForwardWithinLine(sc)) {
+						break;
+					}
+				}
+				break;
+
+			case SCE_HEX_DATA_ODD:
+			case SCE_HEX_DATA_EVEN:
+			case SCE_HEX_GARBAGE:
+				// record finished or line too long
+				sc.SetState(SCE_HEX_GARBAGE);
+				ForwardWithinLine(sc);
+				break;
+
+			default:
+				// prevent endless loop in faulty state
+				sc.SetState(SCE_HEX_DEFAULT);
+				break;
+		}
+	}
+	sc.Complete();
+}
+
+LexerModule lmSrec(SCLEX_SREC, ColouriseSrecDoc, "srec", 0, NULL);
+LexerModule lmIHex(SCLEX_IHEX, ColouriseIHexDoc, "ihex", FoldIHexDoc, NULL);
+LexerModule lmTEHex(SCLEX_TEHEX, ColouriseTEHexDoc, "tehex", 0, NULL);
diff --git a/ext/scintilla/lexers/LexVerilog.cxx b/ext/scintilla/lexers/LexVerilog.cxx
index e27de36ba..d41ea8486 100644
--- a/ext/scintilla/lexers/LexVerilog.cxx
+++ b/ext/scintilla/lexers/LexVerilog.cxx
@@ -13,6 +13,11 @@
 #include <assert.h>
 #include <ctype.h>
 
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
 #include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
@@ -24,10 +29,309 @@
 #include "CharacterSet.h"
 #include "LexerModule.h"
 
+#include "OptionSet.h"
+#include "SubStyles.h"
+
 #ifdef SCI_NAMESPACE
 using namespace Scintilla;
 #endif
 
+namespace {
+	// Use an unnamed namespace to protect the functions and classes from name conflicts
+
+struct PPDefinition {
+	int line;
+	std::string key;
+	std::string value;
+	bool 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_) {
+	}
+};
+
+class LinePPState {
+	int state;
+	int ifTaken;
+	int level;
+	bool ValidLevel() const {
+		return level >= 0 && level < 32;
+	}
+	int maskLevel() const {
+		return 1 << level;
+	}
+public:
+	LinePPState() : state(0), ifTaken(0), level(-1) {
+	}
+	bool IsInactive() const {
+		return state != 0;
+	}
+	bool CurrentIfTaken() const {
+		return (ifTaken & maskLevel()) != 0;
+	}
+	void StartSection(bool on) {
+		level++;
+		if (ValidLevel()) {
+			if (on) {
+				state &= ~maskLevel();
+				ifTaken |= maskLevel();
+			} else {
+				state |= maskLevel();
+				ifTaken &= ~maskLevel();
+			}
+		}
+	}
+	void EndSection() {
+		if (ValidLevel()) {
+			state &= ~maskLevel();
+			ifTaken &= ~maskLevel();
+		}
+		level--;
+	}
+	void InvertCurrentLevel() {
+		if (ValidLevel()) {
+			state ^= maskLevel();
+			ifTaken |= maskLevel();
+		}
+	}
+};
+
+// Hold the preprocessor state for each line seen.
+// Currently one entry per line but could become sparse with just one entry per preprocessor line.
+class PPStates {
+	std::vector<LinePPState> vlls;
+public:
+	LinePPState ForLine(int line) const {
+		if ((line > 0) && (vlls.size() > static_cast<size_t>(line))) {
+			return vlls[line];
+		} else {
+			return LinePPState();
+		}
+	}
+	void Add(int line, LinePPState lls) {
+		vlls.resize(line+1);
+		vlls[line] = lls;
+	}
+};
+
+// Options used for LexerVerilog
+struct OptionsVerilog {
+	bool foldComment;
+	bool foldPreprocessor;
+	bool foldCompact;
+	bool foldAtElse;
+	bool foldAtModule;
+	bool trackPreprocessor;
+	bool updatePreprocessor;
+	bool portStyling;
+	bool allUppercaseDocKeyword;
+	OptionsVerilog() {
+		foldComment = false;
+		foldPreprocessor = false;
+		foldCompact = false;
+		foldAtElse = false;
+		foldAtModule = false;
+		// for backwards compatibility, preprocessor functionality is disabled by default
+		trackPreprocessor = false;
+		updatePreprocessor = false;
+		// for backwards compatibility, treat input/output/inout as regular keywords
+		portStyling = false;
+		// for backwards compatibility, don't treat all uppercase identifiers as documentation keywords
+		allUppercaseDocKeyword = false;
+	}
+};
+
+struct OptionSetVerilog : public OptionSet<OptionsVerilog> {
+	OptionSetVerilog() {
+		DefineProperty("fold.comment", &OptionsVerilog::foldComment,
+			"This option enables folding multi-line comments when using the Verilog lexer.");
+		DefineProperty("fold.preprocessor", &OptionsVerilog::foldPreprocessor,
+			"This option enables folding preprocessor directives when using the Verilog lexer.");
+		DefineProperty("fold.compact", &OptionsVerilog::foldCompact);
+		DefineProperty("fold.at.else", &OptionsVerilog::foldAtElse,
+			"This option enables folding on the else line of an if statement.");
+		DefineProperty("fold.verilog.flags", &OptionsVerilog::foldAtModule,
+			"This option enables folding module definitions. Typically source files "
+			"contain only one module definition so this option is somewhat useless.");
+		DefineProperty("lexer.verilog.track.preprocessor", &OptionsVerilog::trackPreprocessor,
+			"Set to 1 to interpret `if/`else/`endif to grey out code that is not active.");
+		DefineProperty("lexer.verilog.update.preprocessor", &OptionsVerilog::updatePreprocessor,
+			"Set to 1 to update preprocessor definitions when `define, `undef, or `undefineall found.");
+		DefineProperty("lexer.verilog.portstyling", &OptionsVerilog::portStyling,
+			"Set to 1 to style input, output, and inout ports differently from regular keywords.");
+		DefineProperty("lexer.verilog.allupperkeywords", &OptionsVerilog::allUppercaseDocKeyword,
+			"Set to 1 to style identifiers that are all uppercase as documentation keyword.");
+	}
+};
+
+const char styleSubable[] = {0};
+
+}
+
+class LexerVerilog : public ILexerWithSubStyles {
+	CharacterSet setWord;
+	WordList keywords;
+	WordList keywords2;
+	WordList keywords3;
+	WordList keywords4;
+	WordList keywords5;
+	WordList ppDefinitions;
+	PPStates vlls;
+	std::vector<PPDefinition> ppDefineHistory;
+	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;
+	OptionsVerilog options;
+	OptionSetVerilog osVerilog;
+	enum { activeFlag = 0x40 };
+	SubStyles subStyles;
+public:
+	LexerVerilog() :
+		setWord(CharacterSet::setAlphaNum, "._", 0x80, true),
+		subStyles(styleSubable, 0x80, 0x40, activeFlag) {
+		}
+	virtual ~LexerVerilog() {}
+	int SCI_METHOD Version() const {
+		return lvSubStyles;
+	}
+	void SCI_METHOD Release() {
+		delete this;
+	}
+	const char* SCI_METHOD PropertyNames() {
+		return osVerilog.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char* name) {
+		return osVerilog.PropertyType(name);
+	}
+	const char* SCI_METHOD DescribeProperty(const char* name) {
+		return osVerilog.DescribeProperty(name);
+	}
+	int SCI_METHOD PropertySet(const char* key, const char* val) {
+	    return osVerilog.PropertySet(&options, key, val);
+	}
+	const char* SCI_METHOD DescribeWordListSets() {
+		return osVerilog.DescribeWordListSets();
+	}
+	int SCI_METHOD WordListSet(int n, const char* wl);
+	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	void* SCI_METHOD PrivateCall(int, void*) {
+		return 0;
+	}
+	int SCI_METHOD LineEndTypesSupported() {
+		return SC_LINE_END_TYPE_UNICODE;
+	}
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) {
+		return subStyles.Allocate(styleBase, numberStyles);
+	}
+	int SCI_METHOD SubStylesStart(int styleBase) {
+		return subStyles.Start(styleBase);
+	}
+	int SCI_METHOD SubStylesLength(int styleBase) {
+		return subStyles.Length(styleBase);
+	}
+	int SCI_METHOD StyleFromSubStyle(int subStyle) {
+		int styleBase = subStyles.BaseStyle(MaskActive(subStyle));
+		int active = subStyle & activeFlag;
+		return styleBase | active;
+	}
+	int SCI_METHOD PrimaryStyleFromStyle(int style) {
+		return MaskActive(style);
+ 	}
+	void SCI_METHOD FreeSubStyles() {
+		subStyles.Free();
+	}
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) {
+		subStyles.SetIdentifiers(style, identifiers);
+	}
+	int SCI_METHOD DistanceToSecondaryStyles() {
+		return activeFlag;
+	}
+	const char * SCI_METHOD GetSubStyleBases() {
+		return styleSubable;
+	}
+	static ILexer* LexerFactoryVerilog() {
+		return new LexerVerilog();
+	}
+	static int MaskActive(int style) {
+		return style & ~activeFlag;
+	}
+	std::vector<std::string> Tokenize(const std::string &expr) const;
+};
+
+int SCI_METHOD LexerVerilog::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	case 2:
+		wordListN = &keywords3;
+		break;
+	case 3:
+		wordListN = &keywords4;
+		break;
+	case 4:
+		wordListN = &keywords5;
+		break;
+	case 5:
+		wordListN = &ppDefinitions;
+		break;
+	}
+	int firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+			if (n == 5) {
+				// Rebuild preprocessorDefinitions
+				preprocessorDefinitionsStart.clear();
+				for (int nDefinition = 0; nDefinition < ppDefinitions.Length(); nDefinition++) {
+					const char *cpDefinition = ppDefinitions.WordAt(nDefinition);
+					const char *cpEquals = strchr(cpDefinition, '=');
+					if (cpEquals) {
+						std::string name(cpDefinition, cpEquals - cpDefinition);
+						std::string val(cpEquals+1);
+						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");
+						preprocessorDefinitionsStart[name] = val;
+					}
+				}
+			}
+		}
+	}
+	return firstModification;
+}
+
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '\''|| ch == '$');
 }
@@ -36,116 +340,389 @@ static inline bool IsAWordStart(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '$');
 }
 
-static void ColouriseVerilogDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
+static inline bool AllUpperCase(const char *a) {
+	while (*a) {
+		if (*a >= 'a' && *a <= 'z') return false;
+		a++;
+	}
+	return true;
+}
 
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
+// Functor used to truncate history
+struct After {
+	int line;
+	explicit After(int line_) : line(line_) {}
+	bool operator()(PPDefinition &p) const {
+		return p.line > line;
+	}
+};
+
+static std::string GetRestOfLine(LexAccessor &styler, int start, bool allowSpace) {
+	std::string restOfLine;
+	int i =0;
+	char ch = styler.SafeGetCharAt(start, '\n');
+	int endLine = styler.LineEnd(styler.GetLine(start));
+	while (((start+i) < endLine) && (ch != '\r')) {
+		char chNext = styler.SafeGetCharAt(start + i + 1, '\n');
+		if (ch == '/' && (chNext == '/' || chNext == '*'))
+			break;
+		if (allowSpace || (ch != ' '))
+			restOfLine += ch;
+		i++;
+		ch = chNext;
+	}
+	return restOfLine;
+}
+
+static bool IsSpaceOrTab(int ch) {
+	return ch == ' ' || ch == '\t';
+}
+
+void SCI_METHOD LexerVerilog::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess)
+{
+	LexAccessor styler(pAccess);
+
+	const int kwOther=0, kwDot=0x100, kwInput=0x200, kwOutput=0x300, kwInout=0x400;
+	int lineState = kwOther;
+	bool continuationLine = false;
+
+	int curLine = styler.GetLine(startPos);
+	if (curLine > 0) lineState = styler.GetLineState(curLine - 1);
 
 	// Do not leak onto next line
 	if (initStyle == SCE_V_STRINGEOL)
 		initStyle = SCE_V_DEFAULT;
 
+	if ((MaskActive(initStyle) == SCE_V_PREPROCESSOR) ||
+			(MaskActive(initStyle) == SCE_V_COMMENTLINE) ||
+			(MaskActive(initStyle) == SCE_V_COMMENTLINEBANG)) {
+		// Set continuationLine if last character of previous line is '\'
+		if (curLine > 0) {
+			int endLinePrevious = styler.LineEnd(curLine - 1);
+			if (endLinePrevious > 0) {
+				continuationLine = styler.SafeGetCharAt(endLinePrevious-1) == '\\';
+			}
+		}
+	}
+
 	StyleContext sc(startPos, length, initStyle, styler);
+	LinePPState preproc = vlls.ForLine(curLine);
+
+	bool definitionsChanged = false;
+
+	// Truncate ppDefineHistory before current line
+
+	if (!options.updatePreprocessor)
+		ppDefineHistory.clear();
+
+	std::vector<PPDefinition>::iterator itInvalid = std::find_if(ppDefineHistory.begin(), ppDefineHistory.end(), After(curLine-1));
+	if (itInvalid != ppDefineHistory.end()) {
+		ppDefineHistory.erase(itInvalid, ppDefineHistory.end());
+		definitionsChanged = true;
+	}
+
+	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] = SymbolValue(itDef->value, itDef->arguments);
+	}
+
+	int activitySet = preproc.IsInactive() ? activeFlag : 0;
+	int lineEndNext = styler.LineEnd(curLine);
 
 	for (; sc.More(); sc.Forward()) {
+		if (sc.atLineStart) {
+			if (sc.state == SCE_V_STRING) {
+				// Prevent SCE_V_STRINGEOL from leaking back to previous line
+				sc.SetState(SCE_V_STRING);
+			}
+			if ((MaskActive(sc.state) == SCE_V_PREPROCESSOR) && (!continuationLine)) {
+				sc.SetState(SCE_V_DEFAULT|activitySet);
+			}
+			if (preproc.IsInactive()) {
+				activitySet = activeFlag;
+				sc.SetState(sc.state | activitySet);
+			}
+		}
 
-		if (sc.atLineStart && (sc.state == SCE_V_STRING)) {
-			// Prevent SCE_V_STRINGEOL from leaking back to previous line
-			sc.SetState(SCE_V_STRING);
+		if (sc.atLineEnd) {
+			curLine++;
+			lineEndNext = styler.LineEnd(curLine);
+			vlls.Add(curLine, preproc);
+			// Update the line state, so it can be seen by next line
+			styler.SetLineState(curLine, lineState);
 		}
 
 		// Handle line continuation generically.
 		if (sc.ch == '\\') {
-			if (sc.chNext == '\n' || sc.chNext == '\r') {
+			if (static_cast<int>((sc.currentPos+1)) >= lineEndNext) {
+				curLine++;
+				lineEndNext = styler.LineEnd(curLine);
+				vlls.Add(curLine, preproc);
+				// Update the line state, so it can be seen by next line
+				styler.SetLineState(curLine, lineState);
 				sc.Forward();
 				if (sc.ch == '\r' && sc.chNext == '\n') {
+					// Even in UTF-8, \r and \n are separate
 					sc.Forward();
 				}
+				continuationLine = true;
+				sc.Forward();
 				continue;
 			}
 		}
 
-		// Determine if the current state should terminate.
-		if (sc.state == SCE_V_OPERATOR) {
-			sc.SetState(SCE_V_DEFAULT);
-		} else if (sc.state == SCE_V_NUMBER) {
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_V_DEFAULT);
+		// for comment keyword
+		if (MaskActive(sc.state) == SCE_V_COMMENT_WORD && !IsAWordChar(sc.ch)) {
+			char s[100];
+			int state = lineState & 0xff;
+			sc.GetCurrent(s, sizeof(s));
+			if (keywords5.InList(s)) {
+				sc.ChangeState(SCE_V_COMMENT_WORD|activitySet);
+			} else {
+				sc.ChangeState(state|activitySet);
 			}
-		} else if (sc.state == SCE_V_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch) || (sc.ch == '.')) {
-				char s[100];
-                                sc.GetCurrent(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.ChangeState(SCE_V_WORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_V_WORD2);
-				} else if (keywords3.InList(s)) {
-					sc.ChangeState(SCE_V_WORD3);
-                                } else if (keywords4.InList(s)) {
-					sc.ChangeState(SCE_V_USER);
+			sc.SetState(state|activitySet);
+		}
+
+		const bool atLineEndBeforeSwitch = sc.atLineEnd;
+
+		// Determine if the current state should terminate.
+		switch (MaskActive(sc.state)) {
+			case SCE_V_OPERATOR:
+				sc.SetState(SCE_V_DEFAULT|activitySet);
+				break;
+			case SCE_V_NUMBER:
+				if (!(IsAWordChar(sc.ch) || (sc.ch == '?'))) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
 				}
-				sc.SetState(SCE_V_DEFAULT);
-			}
-		} else if (sc.state == SCE_V_PREPROCESSOR) {
-                        if (!IsAWordChar(sc.ch)) {
-                                sc.SetState(SCE_V_DEFAULT);
-                        }
-		} else if (sc.state == SCE_V_COMMENT) {
-			if (sc.Match('*', '/')) {
-				sc.Forward();
-				sc.ForwardSetState(SCE_V_DEFAULT);
-			}
-		} else if (sc.state == SCE_V_COMMENTLINE || sc.state == SCE_V_COMMENTLINEBANG) {
-			if (sc.atLineStart) {
-				sc.SetState(SCE_V_DEFAULT);
-			}
-                } else if (sc.state == SCE_V_STRING) {
-			if (sc.ch == '\\') {
-				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+				break;
+			case SCE_V_IDENTIFIER:
+				if (!IsAWordChar(sc.ch) || (sc.ch == '.')) {
+					char s[100];
+					lineState &= 0xff00;
+					sc.GetCurrent(s, sizeof(s));
+					if (options.portStyling && (strcmp(s, "input") == 0)) {
+						lineState = kwInput;
+						sc.ChangeState(SCE_V_INPUT|activitySet);
+					} else if (options.portStyling && (strcmp(s, "output") == 0)) {
+						lineState = kwOutput;
+						sc.ChangeState(SCE_V_OUTPUT|activitySet);
+					} else if (options.portStyling && (strcmp(s, "inout") == 0)) {
+						lineState = kwInout;
+						sc.ChangeState(SCE_V_INOUT|activitySet);
+					} else if (lineState == kwInput) {
+						sc.ChangeState(SCE_V_INPUT|activitySet);
+					} else if (lineState == kwOutput) {
+						sc.ChangeState(SCE_V_OUTPUT|activitySet);
+					} else if (lineState == kwInout) {
+						sc.ChangeState(SCE_V_INOUT|activitySet);
+					} else if (lineState == kwDot) {
+						lineState = kwOther;
+						if (options.portStyling)
+							sc.ChangeState(SCE_V_PORT_CONNECT|activitySet);
+					} else if (keywords.InList(s)) {
+						sc.ChangeState(SCE_V_WORD|activitySet);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(SCE_V_WORD2|activitySet);
+					} else if (keywords3.InList(s)) {
+						sc.ChangeState(SCE_V_WORD3|activitySet);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(SCE_V_USER|activitySet);
+					} else if (options.allUppercaseDocKeyword && AllUpperCase(s)) {
+						sc.ChangeState(SCE_V_USER|activitySet);
+					}
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_V_PREPROCESSOR:
+				if (!IsAWordChar(sc.ch) && !sc.atLineEnd) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_V_COMMENT:
+				if (sc.Match('*', '/')) {
 					sc.Forward();
+					sc.ForwardSetState(SCE_V_DEFAULT|activitySet);
+				} else if (IsAWordStart(sc.ch)) {
+					lineState = sc.state | (lineState & 0xff00);
+					sc.SetState(SCE_V_COMMENT_WORD|activitySet);
 				}
-			} else if (sc.ch == '\"') {
-				sc.ForwardSetState(SCE_V_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_V_STRINGEOL);
-				sc.ForwardSetState(SCE_V_DEFAULT);
-			}
+				break;
+			case SCE_V_COMMENTLINE:
+			case SCE_V_COMMENTLINEBANG:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				} else if (IsAWordStart(sc.ch)) {
+					lineState = sc.state | (lineState & 0xff00);
+					sc.SetState(SCE_V_COMMENT_WORD|activitySet);
+				}
+				break;
+			case SCE_V_STRING:
+				if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\"') {
+					sc.ForwardSetState(SCE_V_DEFAULT|activitySet);
+				} else if (sc.atLineEnd) {
+					sc.ChangeState(SCE_V_STRINGEOL|activitySet);
+					sc.ForwardSetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+		}
+
+		if (sc.atLineEnd && !atLineEndBeforeSwitch) {
+			// State exit processing consumed characters up to end of line.
+			curLine++;
+			lineEndNext = styler.LineEnd(curLine);
+			vlls.Add(curLine, preproc);
+			// Update the line state, so it can be seen by next line
+			styler.SetLineState(curLine, lineState);
 		}
 
 		// Determine if a new state should be entered.
-		if (sc.state == SCE_V_DEFAULT) {
+		if (MaskActive(sc.state) == SCE_V_DEFAULT) {
 			if (IsADigit(sc.ch) || (sc.ch == '\'') || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_V_NUMBER);
+				sc.SetState(SCE_V_NUMBER|activitySet);
 			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_V_IDENTIFIER);
+				sc.SetState(SCE_V_IDENTIFIER|activitySet);
 			} else if (sc.Match('/', '*')) {
-                                sc.SetState(SCE_V_COMMENT);
+				sc.SetState(SCE_V_COMMENT|activitySet);
 				sc.Forward();	// Eat the * so it isn't used for the end of the comment
 			} else if (sc.Match('/', '/')) {
 				if (sc.Match("//!"))	// Nice to have a different comment style
-					sc.SetState(SCE_V_COMMENTLINEBANG);
+					sc.SetState(SCE_V_COMMENTLINEBANG|activitySet);
 				else
-					sc.SetState(SCE_V_COMMENTLINE);
+					sc.SetState(SCE_V_COMMENTLINE|activitySet);
 			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_V_STRING);
+				sc.SetState(SCE_V_STRING|activitySet);
 			} else if (sc.ch == '`') {
-				sc.SetState(SCE_V_PREPROCESSOR);
+				sc.SetState(SCE_V_PREPROCESSOR|activitySet);
 				// Skip whitespace between ` and preprocessor word
 				do {
 					sc.Forward();
 				} while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
 				if (sc.atLineEnd) {
-					sc.SetState(SCE_V_DEFAULT);
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+					styler.SetLineState(curLine, lineState);
+				} else {
+					if (options.trackPreprocessor) {
+						if (sc.Match("ifdef") || sc.Match("ifndef")) {
+							bool isIfDef = sc.Match("ifdef");
+							int i = isIfDef ? 5 : 6;
+							std::string restOfLine = GetRestOfLine(styler, sc.currentPos + i + 1, false);
+							bool foundDef = preprocessorDefinitions.find(restOfLine) != preprocessorDefinitions.end();
+							preproc.StartSection(isIfDef == foundDef);
+						} else if (sc.Match("else")) {
+							if (!preproc.CurrentIfTaken()) {
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.IsInactive() ? activeFlag : 0;
+								if (!activitySet) {
+									sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+								}
+							} else if (!preproc.IsInactive()) {
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.IsInactive() ? activeFlag : 0;
+								if (!activitySet) {
+									sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+								}
+							}
+						} else if (sc.Match("elsif")) {
+							// Ensure only one chosen out of `if .. `elsif .. `elsif .. `else .. `endif
+							if (!preproc.CurrentIfTaken()) {
+								// Similar to `ifdef
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true);
+								bool ifGood = preprocessorDefinitions.find(restOfLine) != preprocessorDefinitions.end();
+								if (ifGood) {
+									preproc.InvertCurrentLevel();
+									activitySet = preproc.IsInactive() ? activeFlag : 0;
+									if (!activitySet)
+										sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+								}
+							} else if (!preproc.IsInactive()) {
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.IsInactive() ? activeFlag : 0;
+								if (!activitySet)
+									sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+							}
+						} else if (sc.Match("endif")) {
+							preproc.EndSection();
+							activitySet = preproc.IsInactive() ? activeFlag : 0;
+							sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+						} else if (sc.Match("define")) {
+							if (options.updatePreprocessor && !preproc.IsInactive()) {
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, 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 ((endName < restOfLine.length()) && (restOfLine.at(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;
+									if (startValue < restOfLine.length())
+										value = restOfLine.substr(startValue);
+									preprocessorDefinitions[key] = SymbolValue(value, args);
+									ppDefineHistory.push_back(PPDefinition(curLine, 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(curLine, key, value));
+									definitionsChanged = true;
+								}
+							}
+						} else if (sc.Match("undefineall")) {
+							if (options.updatePreprocessor && !preproc.IsInactive()) {
+								// remove all preprocessor definitions
+								std::map<std::string, SymbolValue>::iterator itDef;
+								for(itDef = preprocessorDefinitions.begin(); itDef != preprocessorDefinitions.end(); ++itDef) {
+									ppDefineHistory.push_back(PPDefinition(curLine, itDef->first, "", true));
+								}
+								preprocessorDefinitions.clear();
+								definitionsChanged = true;
+							}
+						} else if (sc.Match("undef")) {
+							if (options.updatePreprocessor && !preproc.IsInactive()) {
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 5, true);
+								std::vector<std::string> tokens = Tokenize(restOfLine);
+								std::string key;
+								if (tokens.size() >= 1) {
+									key = tokens[0];
+									preprocessorDefinitions.erase(key);
+									ppDefineHistory.push_back(PPDefinition(curLine, key, "", true));
+									definitionsChanged = true;
+								}
+							}
+						}
+					}
 				}
 			} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '@' || sc.ch == '#') {
-				sc.SetState(SCE_V_OPERATOR);
+				sc.SetState(SCE_V_OPERATOR|activitySet);
+				if (sc.ch == '.') lineState = kwDot;
+				if (sc.ch == ';') lineState = kwOther;
 			}
 		}
 	}
+	if (definitionsChanged) {
+		styler.ChangeLexerState(startPos, startPos + length);
+	}
 	sc.Complete();
 }
 
@@ -153,7 +730,7 @@ static bool IsStreamCommentStyle(int style) {
 	return style == SCE_V_COMMENT;
 }
 
-static bool IsCommentLine(int line, Accessor &styler) {
+static bool IsCommentLine(int line, LexAccessor &styler) {
 	int pos = styler.LineStart(line);
 	int eolPos = styler.LineStart(line + 1) - 1;
 	for (int i = pos; i < eolPos; i++) {
@@ -169,22 +746,13 @@ static bool IsCommentLine(int line, Accessor &styler) {
 	}
 	return false;
 }
+
 // Store both the current line's fold level and the next lines in the
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
-static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle,
-                            Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-        // Verilog specific folding options:
-        // fold_at_module -
-        //      Generally used methodology in verilog code is
-        //      one module per file, so folding at module definition is useless.
-        // fold_at_brace/parenthese -
-        //      Folding of long port lists can be convenient.
-	bool foldAtModule = styler.GetPropertyInt("fold.verilog.flags", 0) != 0;
+void SCI_METHOD LexerVerilog::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess)
+{
+	LexAccessor styler(pAccess);
 	bool foldAtBrace  = 1;
 	bool foldAtParenthese  = 1;
 
@@ -197,16 +765,16 @@ static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle
 	int levelMinCurrent = levelCurrent;
 	int levelNext = levelCurrent;
 	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
+	int styleNext = MaskActive(styler.StyleAt(startPos));
+	int style = MaskActive(initStyle);
 	for (unsigned int i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
 		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
+		styleNext = MaskActive(styler.StyleAt(i + 1));
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (foldComment && IsStreamCommentStyle(style)) {
+		if (options.foldComment && IsStreamCommentStyle(style)) {
 			if (!IsStreamCommentStyle(stylePrev)) {
 				levelNext++;
 			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
@@ -214,7 +782,7 @@ static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle
 				levelNext--;
 			}
 		}
-		if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
+		if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler))
 		{
 			if (!IsCommentLine(lineCurrent - 1, styler)
 			    && IsCommentLine(lineCurrent + 1, styler))
@@ -223,7 +791,7 @@ static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle
 			         && !IsCommentLine(lineCurrent+1, styler))
 				levelNext--;
 		}
-		if (foldComment && (style == SCE_V_COMMENTLINE)) {
+		if (options.foldComment && (style == SCE_V_COMMENTLINE)) {
 			if ((ch == '/') && (chNext == '/')) {
 				char chNext2 = styler.SafeGetCharAt(i + 2);
 				if (chNext2 == '{') {
@@ -233,7 +801,7 @@ static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle
 				}
 			}
 		}
-		if (foldPreprocessor && (style == SCE_V_PREPROCESSOR)) {
+		if (options.foldPreprocessor && (style == SCE_V_PREPROCESSOR)) {
 			if (ch == '`') {
 				unsigned int j = i + 1;
 				while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
@@ -246,71 +814,71 @@ static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle
 				}
 			}
 		}
-                if (style == SCE_V_OPERATOR) {
-                    if (foldAtParenthese) {
-			if (ch == '(') {
-				levelNext++;
-			} else if (ch == ')') {
-				levelNext--;
+		if (style == SCE_V_OPERATOR) {
+			if (foldAtParenthese) {
+				if (ch == '(') {
+					levelNext++;
+				} else if (ch == ')') {
+					levelNext--;
+				}
 			}
-                    }
 		}
-                if (style == SCE_V_OPERATOR) {
-                    if (foldAtBrace) {
-			if (ch == '{') {
+		if (style == SCE_V_OPERATOR) {
+			if (foldAtBrace) {
+				if (ch == '{') {
+					levelNext++;
+				} else if (ch == '}') {
+					levelNext--;
+				}
+			}
+		}
+		if (style == SCE_V_WORD && stylePrev != SCE_V_WORD) {
+			unsigned int j = i;
+			if (styler.Match(j, "case") ||
+				styler.Match(j, "casex") ||
+				styler.Match(j, "casez") ||
+				styler.Match(j, "class") ||
+				styler.Match(j, "function") ||
+				styler.Match(j, "generate") ||
+				styler.Match(j, "covergroup") ||
+				styler.Match(j, "package") ||
+				styler.Match(j, "primitive") ||
+				styler.Match(j, "program") ||
+				styler.Match(j, "sequence") ||
+				styler.Match(j, "specify") ||
+				styler.Match(j, "table") ||
+				styler.Match(j, "task") ||
+				styler.Match(j, "fork") ||
+				(styler.Match(j, "module") && options.foldAtModule) ||
+				styler.Match(j, "begin")) {
 				levelNext++;
-			} else if (ch == '}') {
+			} else if (styler.Match(j, "endcase") ||
+				styler.Match(j, "endclass") ||
+				styler.Match(j, "endfunction") ||
+				styler.Match(j, "endgenerate") ||
+				styler.Match(j, "endgroup") ||
+				styler.Match(j, "endpackage") ||
+				styler.Match(j, "endprimitive") ||
+				styler.Match(j, "endprogram") ||
+				styler.Match(j, "endsequence") ||
+				styler.Match(j, "endspecify") ||
+				styler.Match(j, "endtable") ||
+				styler.Match(j, "endtask") ||
+				styler.Match(j, "join") ||
+				styler.Match(j, "join_any") ||
+				styler.Match(j, "join_none") ||
+				(styler.Match(j, "endmodule") && options.foldAtModule) ||
+				(styler.Match(j, "end") && !IsAWordChar(styler.SafeGetCharAt(j + 3)))) {
 				levelNext--;
 			}
-                    }
-		}
-                if (style == SCE_V_WORD && stylePrev != SCE_V_WORD) {
-                        unsigned int j = i;
-                        if (styler.Match(j, "case") ||
-                            styler.Match(j, "casex") ||
-                            styler.Match(j, "casez") ||
-                            styler.Match(j, "class") ||
-                            styler.Match(j, "function") ||
-                            styler.Match(j, "generate") ||
-                            styler.Match(j, "covergroup") ||
-                            styler.Match(j, "package") ||
-                            styler.Match(j, "primitive") ||
-                            styler.Match(j, "program") ||
-                            styler.Match(j, "sequence") ||
-                            styler.Match(j, "specify") ||
-                            styler.Match(j, "table") ||
-                            styler.Match(j, "task") ||
-                            styler.Match(j, "fork") ||
-                            (styler.Match(j, "module") && foldAtModule) ||
-                            styler.Match(j, "begin")) {
-                                levelNext++;
-                        } else if (styler.Match(j, "endcase") ||
-                                   styler.Match(j, "endclass") ||
-                                   styler.Match(j, "endfunction") ||
-                                   styler.Match(j, "endgenerate") ||
-                                   styler.Match(j, "endgroup") ||
-                                   styler.Match(j, "endpackage") ||
-                                   styler.Match(j, "endprimitive") ||
-                                   styler.Match(j, "endprogram") ||
-                                   styler.Match(j, "endsequence") ||
-                                   styler.Match(j, "endspecify") ||
-                                   styler.Match(j, "endtable") ||
-                                   styler.Match(j, "endtask") ||
-                                   styler.Match(j, "join") ||
-                                   styler.Match(j, "join_any") ||
-                                   styler.Match(j, "join_none") ||
-                                   (styler.Match(j, "endmodule") && foldAtModule) ||
-                                   (styler.Match(j, "end") && !IsAWordChar(styler.SafeGetCharAt(j+3)))) {
-                                levelNext--;
-                        }
 		}
 		if (atEOL) {
 			int levelUse = levelCurrent;
-			if (foldAtElse) {
+			if (options.foldAtElse) {
 				levelUse = levelMinCurrent;
 			}
 			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && foldCompact)
+			if (visibleChars == 0 && options.foldCompact)
 				lev |= SC_FOLDLEVELWHITEFLAG;
 			if (levelUse < levelNext)
 				lev |= SC_FOLDLEVELHEADERFLAG;
@@ -327,9 +895,31 @@ static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle
 	}
 }
 
-static void FoldVerilogDoc(unsigned int startPos, int length, int initStyle, WordList *[],
-                       Accessor &styler) {
-	FoldNoBoxVerilogDoc(startPos, length, initStyle, styler);
+std::vector<std::string> LexerVerilog::Tokenize(const std::string &expr) const {
+	// Break into tokens
+	std::vector<std::string> tokens;
+	const char *cp = expr.c_str();
+	while (*cp) {
+		std::string word;
+		if (setWord.Contains(static_cast<unsigned char>(*cp))) {
+			// Identifiers and numbers
+			while (setWord.Contains(static_cast<unsigned char>(*cp))) {
+				word += *cp;
+				cp++;
+			}
+		} else if (IsSpaceOrTab(*cp)) {
+			while (IsSpaceOrTab(*cp)) {
+				cp++;
+			}
+			continue;
+		} else {
+			// Should handle strings, characters, and comments here
+			word += *cp;
+			cp++;
+		}
+		tokens.push_back(word);
+	}
+	return tokens;
 }
 
 static const char * const verilogWordLists[] = {
@@ -337,9 +927,9 @@ static const char * const verilogWordLists[] = {
             "Secondary keywords and identifiers",
             "System Tasks",
             "User defined tasks and identifiers",
-            "Unused",
+            "Documentation comment keywords",
+            "Preprocessor definitions",
             0,
         };
 
-
-LexerModule lmVerilog(SCLEX_VERILOG, ColouriseVerilogDoc, "verilog", FoldVerilogDoc, verilogWordLists);
+LexerModule lmVerilog(SCLEX_VERILOG, LexerVerilog::LexerFactoryVerilog, "verilog", verilogWordLists);
diff --git a/ext/scintilla/lexlib/LexAccessor.h b/ext/scintilla/lexlib/LexAccessor.h
index 248f1c54b..ba4a0e27a 100644
--- a/ext/scintilla/lexlib/LexAccessor.h
+++ b/ext/scintilla/lexlib/LexAccessor.h
@@ -58,6 +58,9 @@ public:
 		validLen(0),
 		startSeg(0), startPosStyling(0),
 		documentVersion(pAccess->Version()) {
+		// Prevent warnings by static analyzers about uninitialized buf and styleBuf.
+		buf[0] = 0;
+		styleBuf[0] = 0;
 		switch (codePage) {
 		case 65001:
 			encodingType = encUnicode;
diff --git a/ext/scintilla/lexlib/WordList.cxx b/ext/scintilla/lexlib/WordList.cxx
index ce94b5238..7ac00ad2b 100644
--- a/ext/scintilla/lexlib/WordList.cxx
+++ b/ext/scintilla/lexlib/WordList.cxx
@@ -69,6 +69,8 @@ static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = fa
 
 WordList::WordList(bool onlyLineEnds_) :
 	words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) {
+	// Prevent warnings by static analyzers about uninitialized starts.
+	starts[0] = -1;
 }
 
 WordList::~WordList() {
diff --git a/ext/scintilla/src/Catalogue.cxx b/ext/scintilla/src/Catalogue.cxx
index 073fe5f40..c54bb48f3 100644
--- a/ext/scintilla/src/Catalogue.cxx
+++ b/ext/scintilla/src/Catalogue.cxx
@@ -123,6 +123,7 @@ int Scintilla_LinkLexers() {
 	LINK_LEXER(lmGui4Cli);
 	LINK_LEXER(lmHaskell);
 	LINK_LEXER(lmHTML);
+	LINK_LEXER(lmIHex);
 	LINK_LEXER(lmInno);
 	LINK_LEXER(lmKix);
 	LINK_LEXER(lmKVIrc);
@@ -174,12 +175,14 @@ int Scintilla_LinkLexers() {
 	LINK_LEXER(lmSpecman);
 	LINK_LEXER(lmSpice);
 	LINK_LEXER(lmSQL);
+	LINK_LEXER(lmSrec);
 	LINK_LEXER(lmSTTXT);
 	LINK_LEXER(lmTACL);
 	LINK_LEXER(lmTADS3);
 	LINK_LEXER(lmTAL);
 	LINK_LEXER(lmTCL);
 	LINK_LEXER(lmTCMD);
+	LINK_LEXER(lmTEHex);
 	LINK_LEXER(lmTeX);
 	LINK_LEXER(lmTxt2tags);
 	LINK_LEXER(lmVB);
diff --git a/ext/scintilla/src/Document.cxx b/ext/scintilla/src/Document.cxx
index 8bb1b7ae6..177065747 100644
--- a/ext/scintilla/src/Document.cxx
+++ b/ext/scintilla/src/Document.cxx
@@ -37,6 +37,7 @@
 #include "Document.h"
 #include "RESearch.h"
 #include "UniConversion.h"
+#include "UnicodeFromUTF8.h"
 
 #ifdef SCI_NAMESPACE
 using namespace Scintilla;
@@ -766,19 +767,6 @@ bool Document::NextCharacter(int &pos, int moveDir) const {
 	}
 }
 
-static inline int UnicodeFromBytes(const unsigned char *us) {
-	if (us[0] < 0xC2) {
-		return us[0];
-	} else if (us[0] < 0xE0) {
-		return ((us[0] & 0x1F) << 6) + (us[1] & 0x3F);
-	} else if (us[0] < 0xF0) {
-		return ((us[0] & 0xF) << 12) + ((us[1] & 0x3F) << 6) + (us[2] & 0x3F);
-	} else if (us[0] < 0xF5) {
-		return ((us[0] & 0x7) << 18) + ((us[1] & 0x3F) << 12) + ((us[2] & 0x3F) << 6) + (us[3] & 0x3F);
-	}
-	return us[0];
-}
-
 // Return -1  on out-of-bounds
 int SCI_METHOD Document::GetRelativePosition(int positionStart, int characterOffset) const {
 	int pos = positionStart;
@@ -819,7 +807,7 @@ int SCI_METHOD Document::GetCharacterAndWidth(int position, int *pWidth) const {
 					character =  0xDC80 + leadByte;
 				} else {
 					bytesInCharacter = utf8status & UTF8MaskWidth;
-					character = UnicodeFromBytes(charBytes);
+					character = UnicodeFromUTF8(charBytes);
 				}
 			}
 		} else {
@@ -1610,7 +1598,7 @@ Document::CharacterExtracted Document::ExtractCharacter(int position) const {
 		// Treat as invalid and use up just one byte
 		return CharacterExtracted(unicodeReplacementChar, 1);
 	} else {
-		return CharacterExtracted(UnicodeFromBytes(charBytes), utf8status & UTF8MaskWidth);
+		return CharacterExtracted(UnicodeFromUTF8(charBytes), utf8status & UTF8MaskWidth);
 	}
 }
 
diff --git a/ext/scintilla/src/EditView.cxx b/ext/scintilla/src/EditView.cxx
index 50d2488ea..11c7fed33 100644
--- a/ext/scintilla/src/EditView.cxx
+++ b/ext/scintilla/src/EditView.cxx
@@ -47,7 +47,6 @@
 #include "EditModel.h"
 #include "MarginView.h"
 #include "EditView.h"
-#include "Editor.h"
 
 #ifdef SCI_NAMESPACE
 using namespace Scintilla;
@@ -190,7 +189,6 @@ EditView::EditView() {
 	tabArrowHeight = 4;
 	customDrawTabArrow = NULL;
 	customDrawWrapMarker = NULL;
-	editor = NULL;
 }
 
 EditView::~EditView() {
@@ -1642,17 +1640,7 @@ void EditView::DrawLine(Surface *surface, const EditModel &model, const ViewStyl
 	}
 
 	// See if something overrides the line background color.
-	ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
-	SCNotification scn = { 0 };
-	scn.nmhdr.code = SCN_GETBKCOLOR;
-	scn.line = line;
-	scn.lParam = -1;
-	if (editor)
-		((Editor*)editor)->NotifyParent(&scn);
-	if (scn.lParam != -1) {
-		background.Set(scn.lParam);
-		background.isSet = true;
-	}
+	const ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
 
 	const int posLineStart = model.pdoc->LineStart(line);
 
diff --git a/ext/scintilla/src/EditView.h b/ext/scintilla/src/EditView.h
index d667f67cd..83483625c 100644
--- a/ext/scintilla/src/EditView.h
+++ b/ext/scintilla/src/EditView.h
@@ -76,7 +76,6 @@ public:
 	Surface *pixmapLine;
 	Surface *pixmapIndentGuide;
 	Surface *pixmapIndentGuideHighlight;
-	void	*editor;
 
 	LineLayoutCache llc;
 	PositionCache posCache;
diff --git a/ext/scintilla/src/Editor.cxx b/ext/scintilla/src/Editor.cxx
index 376b32e5c..275835bce 100644
--- a/ext/scintilla/src/Editor.cxx
+++ b/ext/scintilla/src/Editor.cxx
@@ -8,10 +8,10 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <math.h>
 #include <assert.h>
 #include <ctype.h>
 
+#include <cmath>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -100,7 +100,6 @@ static inline bool IsAllSpacesOrTabs(const char *s, unsigned int len) {
 }
 
 Editor::Editor() {
-	view.editor = this;
 	ctrlID = 0;
 
 	stylesValid = false;
@@ -1334,7 +1333,9 @@ void Editor::ShowCaretAtCurrentPosition() {
 
 void Editor::DropCaret() {
 	caret.active = false;
-	FineTickerCancel(tickCaret);
+	if (FineTickerAvailable()) {
+		FineTickerCancel(tickCaret);
+	}
 	InvalidateCaret();
 }
 
@@ -1899,6 +1900,13 @@ void Editor::AddCharUTF(const char *s, unsigned int len, bool treatAsDBCS) {
 	}
 }
 
+void Editor::FillVirtualSpace() {
+	const bool tmpOverstrike = inOverstrike;
+	inOverstrike = false;         // not allow to be deleted twice.
+	AddCharUTF("", 0);
+	inOverstrike = tmpOverstrike;
+}
+
 void Editor::InsertPaste(const char *text, int len) {
 	if (multiPasteMode == SC_MULTIPASTE_ONCE) {
 		SelectionPosition selStart = sel.Start();
@@ -3284,7 +3292,6 @@ int Editor::KeyCommand(unsigned int iMessage) {
 		break;
 	case SCI_EDITTOGGLEOVERTYPE:
 		inOverstrike = !inOverstrike;
-		DropCaret();
 		ShowCaretAtCurrentPosition();
 		ContainerNeedsUpdate(SC_UPDATE_CONTENT);
 		NotifyUpdateUI();
@@ -3780,9 +3787,9 @@ void Editor::GoToLine(int lineNo) {
 }
 
 static bool Close(Point pt1, Point pt2, Point threshold) {
-	if (abs(pt1.x - pt2.x) > threshold.x)
+	if (std::abs(pt1.x - pt2.x) > threshold.x)
 		return false;
-	if (abs(pt1.y - pt2.y) > threshold.y)
+	if (std::abs(pt1.y - pt2.y) > threshold.y)
 		return false;
 	return true;
 }
@@ -4001,7 +4008,7 @@ bool Editor::PointInSelMargin(Point pt) const {
 		PRectangle rcSelMargin = GetClientRectangle();
 		rcSelMargin.right = static_cast<XYPOSITION>(vs.textStart - vs.leftMarginWidth);
 		rcSelMargin.left = static_cast<XYPOSITION>(vs.textStart - vs.fixedColumnWidth);
-		return rcSelMargin.Contains(pt);
+		return rcSelMargin.ContainsWholePixel(pt);
 	} else {
 		return false;
 	}
@@ -4672,12 +4679,10 @@ void Editor::FineTickerCancel(TickReason) {
 void Editor::SetFocusState(bool focusState) {
 	hasFocus = focusState;
 	NotifyFocus(hasFocus);
-	if (hasFocus) {
-		ShowCaretAtCurrentPosition();
-	} else {
+	if (!hasFocus) {
 		CancelModes();
-		DropCaret();
 	}
+	ShowCaretAtCurrentPosition();
 }
 
 int Editor::PositionAfterArea(PRectangle rcArea) const {
diff --git a/ext/scintilla/src/Editor.h b/ext/scintilla/src/Editor.h
index 934d77554..d65d0b8e7 100644
--- a/ext/scintilla/src/Editor.h
+++ b/ext/scintilla/src/Editor.h
@@ -388,6 +388,7 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	int InsertSpace(int position, unsigned int spaces);
 	void AddChar(char ch);
 	virtual void AddCharUTF(const char *s, unsigned int len, bool treatAsDBCS=false);
+	void FillVirtualSpace();
 	void InsertPaste(const char *text, int len);
 	enum PasteShape { pasteStream=0, pasteRectangular = 1, pasteLine = 2 };
 	void InsertPasteShape(const char *text, int len, PasteShape shape);
@@ -560,7 +561,6 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	static sptr_t BytesResult(sptr_t lParam, const unsigned char *val, size_t len);
 
 public:
-	virtual void NotifyParent(SCNotification * scn) = 0;
 	// Public so the COM thunks can access it.
 	bool IsUnicodeMode() const;
 	// Public so scintilla_send_message can use it.
diff --git a/ext/scintilla/src/MarginView.cxx b/ext/scintilla/src/MarginView.cxx
index 075adb2ac..b164044b3 100644
--- a/ext/scintilla/src/MarginView.cxx
+++ b/ext/scintilla/src/MarginView.cxx
@@ -263,8 +263,10 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 				PLATFORM_ASSERT(visibleLine < model.cs.LinesDisplayed());
 				const int lineDoc = model.cs.DocFromDisplay(visibleLine);
 				PLATFORM_ASSERT(model.cs.GetVisible(lineDoc));
-				const bool firstSubLine = visibleLine == model.cs.DisplayFromDoc(lineDoc);
-				const bool lastSubLine = visibleLine == model.cs.DisplayLastFromDoc(lineDoc);
+				const int firstVisibleLine = model.cs.DisplayFromDoc(lineDoc);
+				const int lastVisibleLine = model.cs.DisplayLastFromDoc(lineDoc);
+				const bool firstSubLine = visibleLine == firstVisibleLine;
+				const bool lastSubLine = visibleLine == lastVisibleLine;
 
 				int marks = model.pdoc->GetMark(lineDoc);
 				if (!firstSubLine)
@@ -403,9 +405,9 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 						}
 					}
 				} else if (vs.ms[margin].style == SC_MARGIN_TEXT || vs.ms[margin].style == SC_MARGIN_RTEXT) {
-					if (firstSubLine) {
-						const StyledText stMargin = model.pdoc->MarginStyledText(lineDoc);
-						if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) {
+					const StyledText stMargin = model.pdoc->MarginStyledText(lineDoc);
+					if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) {
+						if (firstSubLine) {
 							surface->FillRectangle(rcMarker,
 								vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
 							if (vs.ms[margin].style == SC_MARGIN_RTEXT) {
@@ -414,6 +416,12 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 							}
 							DrawStyledText(surface, vs, vs.marginStyleOffset, rcMarker,
 								stMargin, 0, stMargin.length, drawAll);
+						} else {
+							// if we're displaying annotation lines, color the margin to match the associated document line
+							const int annotationLines = model.pdoc->AnnotationLines(lineDoc);
+							if (annotationLines && (visibleLine > lastVisibleLine - annotationLines)) {
+								surface->FillRectangle(rcMarker, vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
+							}
 						}
 					}
 				}
diff --git a/ext/scintilla/src/ScintillaBase.cxx b/ext/scintilla/src/ScintillaBase.cxx
index 516a5590e..906f764d7 100644
--- a/ext/scintilla/src/ScintillaBase.cxx
+++ b/ext/scintilla/src/ScintillaBase.cxx
@@ -449,12 +449,12 @@ void ScintillaBase::CallTipShow(Point pt, const char *defn) {
 	PRectangle rcClient = GetClientRectangle();
 	int offset = vs.lineHeight + static_cast<int>(rc.Height());
 	// adjust so it displays above the text.
-	if (rc.bottom > rcClient.bottom) {
+	if (rc.bottom > rcClient.bottom && rc.Height() < rcClient.Height()) {
 		rc.top -= offset;
 		rc.bottom -= offset;
 	}
 	// adjust so it displays below the text.
-	if (rc.top < rcClient.top) {
+	if (rc.top < rcClient.top && rc.Height() < rcClient.Height()) {
 		rc.top += offset;
 		rc.bottom += offset;
 	}
diff --git a/ext/scintilla/src/UniConversion.cxx b/ext/scintilla/src/UniConversion.cxx
index 58651bc2b..f261d126d 100644
--- a/ext/scintilla/src/UniConversion.cxx
+++ b/ext/scintilla/src/UniConversion.cxx
@@ -82,10 +82,10 @@ unsigned int UTF8CharLength(unsigned char ch) {
 	}
 }
 
-unsigned int UTF16Length(const char *s, unsigned int len) {
-	unsigned int ulen = 0;
-	unsigned int charLen;
-	for (unsigned int i=0; i<len;) {
+size_t UTF16Length(const char *s, size_t len) {
+	size_t ulen = 0;
+	size_t charLen;
+	for (size_t i = 0; i<len;) {
 		unsigned char ch = static_cast<unsigned char>(s[i]);
 		if (ch < 0x80) {
 			charLen = 1;
@@ -103,10 +103,10 @@ unsigned int UTF16Length(const char *s, unsigned int len) {
 	return ulen;
 }
 
-unsigned int UTF16FromUTF8(const char *s, unsigned int len, wchar_t *tbuf, unsigned int tlen) {
-	unsigned int ui=0;
+size_t UTF16FromUTF8(const char *s, size_t len, wchar_t *tbuf, size_t tlen) {
+	size_t ui = 0;
 	const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
-	unsigned int i=0;
+	size_t i = 0;
 	while ((i<len) && (ui<tlen)) {
 		unsigned char ch = us[i++];
 		if (ch < 0x80) {
diff --git a/ext/scintilla/src/UniConversion.h b/ext/scintilla/src/UniConversion.h
index 9b302b155..23dcc17da 100644
--- a/ext/scintilla/src/UniConversion.h
+++ b/ext/scintilla/src/UniConversion.h
@@ -19,8 +19,8 @@ const int unicodeReplacementChar = 0xFFFD;
 unsigned int UTF8Length(const wchar_t *uptr, unsigned int tlen);
 void UTF8FromUTF16(const wchar_t *uptr, unsigned int tlen, char *putf, unsigned int len);
 unsigned int UTF8CharLength(unsigned char ch);
-unsigned int UTF16Length(const char *s, unsigned int len);
-unsigned int UTF16FromUTF8(const char *s, unsigned int len, wchar_t *tbuf, unsigned int tlen);
+size_t UTF16Length(const char *s, size_t len);
+size_t UTF16FromUTF8(const char *s, size_t len, wchar_t *tbuf, size_t tlen);
 unsigned int UTF32FromUTF8(const char *s, unsigned int len, unsigned int *tbuf, unsigned int tlen);
 unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf);
 
diff --git a/ext/scintilla/tgzsrc b/ext/scintilla/tgzsrc
deleted file mode 100644
index a4d4ee084..000000000
--- a/ext/scintilla/tgzsrc
+++ /dev/null
@@ -1,4 +0,0 @@
-cd ..
-rm -f scintilla.tgz
-tar --create --exclude \*.o --exclude \*.obj --exclude \*.dll --exclude \*.exe --exclude \*.a scintilla/* \
-	| gzip -c >scintilla.tgz
diff --git a/ext/scintilla/tortoisegit.txt b/ext/scintilla/tortoisegit.txt
index 1abd46ebf..379ba5a2d 100644
--- a/ext/scintilla/tortoisegit.txt
+++ b/ext/scintilla/tortoisegit.txt
@@ -6,4 +6,4 @@ qt
 test
 scripts
 
-apply backgroundcolors.patch and unicodefont.patch
\ No newline at end of file
+apply backgroundcolors.patch
\ No newline at end of file
diff --git a/ext/scintilla/unicodefont.patch b/ext/scintilla/unicodefont.patch
deleted file mode 100644
index 48b613642..000000000
--- a/ext/scintilla/unicodefont.patch
+++ /dev/null
@@ -1,161 +0,0 @@
- ext/scintilla/win32/PlatWin.cxx               | 20 ++++++++++++--------
- ext/scintilla/win32/ScintillaWin.cxx          | 11 ++++++-----
- src/TortoiseGitBlame/TortoiseGitBlameView.cpp |  8 ++++----
- src/TortoiseGitBlame/TortoiseGitBlameView.h   |  2 +-
- src/Utils/MiscUI/SciEdit.cpp                  |  2 +-
- 5 files changed, 24 insertions(+), 19 deletions(-)
-
-diff --git a/ext/scintilla/win32/PlatWin.cxx b/ext/scintilla/win32/PlatWin.cxx
-index c0dbb84..80d8e30 100644
---- a/ext/scintilla/win32/PlatWin.cxx
-+++ b/ext/scintilla/win32/PlatWin.cxx
-@@ -274,15 +274,15 @@ static D2D1_TEXT_ANTIALIAS_MODE DWriteMapFontQuality(int extraFontFlag) {
- }
- #endif
- 
--static void SetLogFont(LOGFONTA &lf, const char *faceName, int characterSet, float size, int weight, bool italic, int extraFontFlag) {
--	lf = LOGFONTA();
-+static void SetLogFont(LOGFONTW &lf, const char *faceName, int characterSet, float size, int weight, bool italic, int extraFontFlag) {
-+	lf = LOGFONTW();
- 	// The negative is to allow for leading
- 	lf.lfHeight = -(abs(static_cast<int>(size + 0.5)));
- 	lf.lfWeight = weight;
- 	lf.lfItalic = static_cast<BYTE>(italic ? 1 : 0);
- 	lf.lfCharSet = static_cast<BYTE>(characterSet);
- 	lf.lfQuality = Win32MapFontQuality(extraFontFlag);
--	StringCopy(lf.lfFaceName, faceName);
-+	UTF16FromUTF8(faceName, strlen(faceName)+1, lf.lfFaceName, LF_FACESIZE);
- }
- 
- /**
-@@ -305,7 +305,7 @@ class FontCached : Font {
- 	FontCached *next;
- 	int usage;
- 	float size;
--	LOGFONTA lf;
-+	LOGFONTW lf;
- 	int technology;
- 	int hash;
- 	explicit FontCached(const FontParameters &fp);
-@@ -328,7 +328,7 @@ FontCached::FontCached(const FontParameters &fp) :
- 	hash = HashFont(fp);
- 	fid = 0;
- 	if (technology == SCWIN_TECH_GDI) {
--		HFONT hfont = ::CreateFontIndirectA(&lf);
-+		HFONT hfont = ::CreateFontIndirectW(&lf);
- 		fid = reinterpret_cast<void *>(new FormatAndMetrics(hfont, fp.extraFontFlag, fp.characterSet));
- 	} else {
- #if defined(USE_D2D)
-@@ -377,14 +377,18 @@ FontCached::FontCached(const FontParameters &fp) :
- }
- 
- bool FontCached::SameAs(const FontParameters &fp) {
--	return
-+	if (
- 		(size == fp.size) &&
- 		(lf.lfWeight == fp.weight) &&
- 		(lf.lfItalic == static_cast<BYTE>(fp.italic ? 1 : 0)) &&
- 		(lf.lfCharSet == fp.characterSet) &&
- 		(lf.lfQuality == Win32MapFontQuality(fp.extraFontFlag)) &&
--		(technology == fp.technology) &&
--		0 == strcmp(lf.lfFaceName,fp.faceName);
-+		(technology == fp.technology)) {
-+		wchar_t wszFace[LF_FACESIZE];
-+		UTF16FromUTF8(fp.faceName, strlen(fp.faceName)+1, wszFace, LF_FACESIZE);
-+		return 0 == wcscmp(lf.lfFaceName,wszFace);
-+	}
-+	return false;
- }
- 
- void FontCached::Release() {
-diff --git a/ext/scintilla/win32/ScintillaWin.cxx b/ext/scintilla/win32/ScintillaWin.cxx
-index a0d9245..5275832 100644
---- a/ext/scintilla/win32/ScintillaWin.cxx
-+++ b/ext/scintilla/win32/ScintillaWin.cxx
-@@ -2161,7 +2161,7 @@ void ScintillaWin::ImeStartComposition() {
- 			// Since the style creation code has been made platform independent,
- 			// The logfont for the IME is recreated here.
- 			int styleHere = (pdoc->StyleAt(sel.MainCaret())) & 31;
--			LOGFONTA lf = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ""};
-+			LOGFONTW lf = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, L""};
- 			int sizeZoomed = vs.styles[styleHere].size + vs.zoomLevel * SC_FONT_SIZE_MULTIPLIER;
- 			if (sizeZoomed <= 2 * SC_FONT_SIZE_MULTIPLIER)	// Hangs if sizeZoomed <= 1
- 				sizeZoomed = 2 * SC_FONT_SIZE_MULTIPLIER;
-@@ -2176,10 +2176,11 @@ void ScintillaWin::ImeStartComposition() {
- 			lf.lfItalic = static_cast<BYTE>(vs.styles[styleHere].italic ? 1 : 0);
- 			lf.lfCharSet = DEFAULT_CHARSET;
- 			lf.lfFaceName[0] = '\0';
--			if (vs.styles[styleHere].fontName)
--				StringCopy(lf.lfFaceName, vs.styles[styleHere].fontName);
--
--			::ImmSetCompositionFontA(hIMC, &lf);
-+			if (vs.styles[styleHere].fontName) {
-+				const char* fontName = vs.styles[styleHere].fontName;
-+				UTF16FromUTF8(fontName, strlen(fontName)+1, lf.lfFaceName, LF_FACESIZE);
-+			}
-+			::ImmSetCompositionFontW(hIMC, &lf);
- 		}
- 		::ImmReleaseContext(MainHWND(), hIMC);
- 		// Caret is displayed in IME window. So, caret in Scintilla is useless.
-diff --git a/src/TortoiseGitBlame/TortoiseGitBlameView.cpp b/src/TortoiseGitBlame/TortoiseGitBlameView.cpp
-index 95c7213..d848953 100644
---- a/src/TortoiseGitBlame/TortoiseGitBlameView.cpp
-+++ b/src/TortoiseGitBlame/TortoiseGitBlameView.cpp
-@@ -625,14 +625,14 @@ LRESULT CTortoiseGitBlameView::SendEditor(UINT Msg, WPARAM wParam, LPARAM lParam
- 	return ::SendMessage(m_wEditor, Msg, wParam, lParam);
- }
- 
--void CTortoiseGitBlameView::SetAStyle(int style, COLORREF fore, COLORREF back, int size, CString *face)
-+void CTortoiseGitBlameView::SetAStyle(int style, COLORREF fore, COLORREF back, int size, const char *face)
- {
- 	SendEditor(SCI_STYLESETFORE, style, fore);
- 	SendEditor(SCI_STYLESETBACK, style, back);
- 	if (size >= 1)
- 		SendEditor(SCI_STYLESETSIZE, style, size);
- 	if (face)
--		SendEditor(SCI_STYLESETFONT, style, reinterpret_cast<LPARAM>(this->m_TextView.StringForControl(*face).GetBuffer()));
-+		SendEditor(SCI_STYLESETFONT, style, reinterpret_cast<LPARAM>(face));
- }
- 
- void CTortoiseGitBlameView::InitialiseEditor()
-@@ -641,12 +641,12 @@ void CTortoiseGitBlameView::InitialiseEditor()
- 	m_directFunction = ::SendMessage(m_wEditor, SCI_GETDIRECTFUNCTION, 0, 0);
- 	m_directPointer = ::SendMessage(m_wEditor, SCI_GETDIRECTPOINTER, 0, 0);
- 	// Set up the global default style. These attributes are used wherever no explicit choices are made.
--	CString fontName(((stdstring)CRegStdString(_T("Software\\TortoiseGit\\BlameFontName"), _T("Courier New"))).c_str());
-+	std::string fontName = CUnicodeUtils::StdGetUTF8((stdstring)CRegStdString(_T("Software\\TortoiseGit\\BlameFontName"), _T("Courier New")));
- 	SetAStyle(STYLE_DEFAULT,
- 			  black,
- 			  white,
- 			(DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\BlameFontSize"), 10),
--			&fontName
-+			fontName.c_str()
- 			);
- 	SendEditor(SCI_SETTABWIDTH, (DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\BlameTabSize"), 4));
- 	SendEditor(SCI_SETREADONLY, TRUE);
-diff --git a/src/TortoiseGitBlame/TortoiseGitBlameView.h b/src/TortoiseGitBlame/TortoiseGitBlameView.h
-index 6982b01..9f631d8 100644
---- a/src/TortoiseGitBlame/TortoiseGitBlameView.h
-+++ b/src/TortoiseGitBlame/TortoiseGitBlameView.h
-@@ -211,7 +211,7 @@ public:
- 
- 	LRESULT SendEditor(UINT Msg, WPARAM wParam=0, LPARAM lParam=0);
- 
--	void SetAStyle(int style, COLORREF fore, COLORREF back = ::GetSysColor(COLOR_WINDOW), int size = -1, CString *face = NULL);
-+	void SetAStyle(int style, COLORREF fore, COLORREF back = ::GetSysColor(COLOR_WINDOW), int size = -1, const char *face = NULL);
- 
- 	void InitialiseEditor();
- 	LONG GetBlameWidth();
-diff --git a/src/Utils/MiscUI/SciEdit.cpp b/src/Utils/MiscUI/SciEdit.cpp
-index 3068c9b..e86fb0b 100644
---- a/src/Utils/MiscUI/SciEdit.cpp
-+++ b/src/Utils/MiscUI/SciEdit.cpp
-@@ -368,7 +368,7 @@ CString CSciEdit::GetWordUnderCursor(bool bSelectWord)
- 
- void CSciEdit::SetFont(CString sFontName, int iFontSizeInPoints)
- {
--	Call(SCI_STYLESETFONT, STYLE_DEFAULT, (LPARAM)(LPCSTR)CStringA(sFontName));
-+	Call(SCI_STYLESETFONT, STYLE_DEFAULT, (LPARAM)(LPCSTR)CUnicodeUtils::GetUTF8(sFontName).GetBuffer());
- 	Call(SCI_STYLESETSIZE, STYLE_DEFAULT, iFontSizeInPoints);
- 	Call(SCI_STYLECLEARALL);
- 
diff --git a/ext/scintilla/version.txt b/ext/scintilla/version.txt
index e64cbb717..8f3487ff1 100644
--- a/ext/scintilla/version.txt
+++ b/ext/scintilla/version.txt
@@ -1 +1 @@
-352
+353
diff --git a/ext/scintilla/win32/PlatWin.cxx b/ext/scintilla/win32/PlatWin.cxx
index 06cc5ceb5..c5dd8355a 100644
--- a/ext/scintilla/win32/PlatWin.cxx
+++ b/ext/scintilla/win32/PlatWin.cxx
@@ -67,7 +67,6 @@ typedef BOOL (WINAPI *GetMonitorInfoSig)(HMONITOR, LPMONITORINFO);
 
 static CRITICAL_SECTION crPlatformLock;
 static HINSTANCE hinstPlatformRes = 0;
-static bool onNT = false;
 
 static HMODULE hDLLImage = 0;
 static AlphaBlendSig AlphaBlendFn = 0;
@@ -83,10 +82,6 @@ static HCURSOR reverseArrowCursor = NULL;
 namespace Scintilla {
 #endif
 
-bool IsNT() {
-	return onNT;
-}
-
 Point Point::FromLong(long lpoint) {
 	return Point(static_cast<short>(LOWORD(lpoint)), static_cast<short>(HIWORD(lpoint)));
 }
@@ -139,16 +134,17 @@ bool LoadD2D() {
 			HRESULT hr = pIDWriteFactory->CreateRenderingParams(&defaultRenderingParams);
 			if (SUCCEEDED(hr)) {
 				unsigned int clearTypeContrast;
-				::SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &clearTypeContrast, 0);
+				if (::SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &clearTypeContrast, 0)) {
 
-				FLOAT gamma;
-				if (clearTypeContrast >= 1000 && clearTypeContrast <= 2200)
-					gamma = static_cast<FLOAT>(clearTypeContrast) / 1000.0f;
-				else
-					gamma = defaultRenderingParams->GetGamma();
+					FLOAT gamma;
+					if (clearTypeContrast >= 1000 && clearTypeContrast <= 2200)
+						gamma = static_cast<FLOAT>(clearTypeContrast) / 1000.0f;
+					else
+						gamma = defaultRenderingParams->GetGamma();
 
-				pIDWriteFactory->CreateCustomRenderingParams(gamma, defaultRenderingParams->GetEnhancedContrast(), defaultRenderingParams->GetClearTypeLevel(),
-					defaultRenderingParams->GetPixelGeometry(), defaultRenderingParams->GetRenderingMode(), &customClearTypeRenderingParams);
+					pIDWriteFactory->CreateCustomRenderingParams(gamma, defaultRenderingParams->GetEnhancedContrast(), defaultRenderingParams->GetClearTypeLevel(),
+						defaultRenderingParams->GetPixelGeometry(), defaultRenderingParams->GetRenderingMode(), &customClearTypeRenderingParams);
+				}
 			}
 		}
 
@@ -335,7 +331,7 @@ FontCached::FontCached(const FontParameters &fp) :
 		IDWriteTextFormat *pTextFormat;
 		const int faceSize = 200;
 		WCHAR wszFace[faceSize];
-		UTF16FromUTF8(fp.faceName, static_cast<unsigned int>(strlen(fp.faceName))+1, wszFace, faceSize);
+		UTF16FromUTF8(fp.faceName, strlen(fp.faceName)+1, wszFace, faceSize);
 		FLOAT fHeight = fp.size;
 		DWRITE_FONT_STYLE style = fp.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
 		HRESULT hr = pIDWriteFactory->CreateTextFormat(wszFace, NULL,
@@ -384,9 +380,9 @@ bool FontCached::SameAs(const FontParameters &fp) {
 		(lf.lfCharSet == fp.characterSet) &&
 		(lf.lfQuality == Win32MapFontQuality(fp.extraFontFlag)) &&
 		(technology == fp.technology)) {
-		wchar_t wszFace[LF_FACESIZE];
-		UTF16FromUTF8(fp.faceName, strlen(fp.faceName)+1, wszFace, LF_FACESIZE);
-		return 0 == wcscmp(lf.lfFaceName,wszFace);
+			wchar_t wszFace[LF_FACESIZE];
+			UTF16FromUTF8(fp.faceName, strlen(fp.faceName)+1, wszFace, LF_FACESIZE);
+			return 0 == wcscmp(lf.lfFaceName,wszFace);
 	}
 	return false;
 }
@@ -490,7 +486,7 @@ public:
 	TextWide(const char *s, int len, bool unicodeMode, int codePage=0) :
 		VarBuffer<wchar_t, stackBufferLength>(len) {
 		if (unicodeMode) {
-			tlen = UTF16FromUTF8(s, len, buffer, len);
+			tlen = static_cast<int>(UTF16FromUTF8(s, len, buffer, len));
 		} else {
 			// Support Asian string display in 9x English
 			tlen = ::MultiByteToWideChar(codePage, 0, s, len, buffer, len);
@@ -515,8 +511,6 @@ class SurfaceGDI : public Surface {
 	int maxLenText;
 
 	int codePage;
-	// If 9x OS and current code page is same as ANSI code page.
-	bool win9xACPSame;
 
 	void BrushColor(ColourDesired back);
 	void SetFont(Font &font_);
@@ -578,14 +572,11 @@ SurfaceGDI::SurfaceGDI() :
 	brush(0), brushOld(0),
 	font(0), 	fontOld(0),
 	bitmap(0), bitmapOld(0) {
-	// Windows 9x has only a 16 bit coordinate system so break after 30000 pixels
-	maxWidthMeasure = IsNT() ? INT_MAX : 30000;
-	// There appears to be a 16 bit string length limit in GDI on NT and a limit of
-	// 8192 characters on Windows 95.
-	maxLenText = IsNT() ? 65535 : 8192;
+	maxWidthMeasure = INT_MAX;
+	// There appears to be a 16 bit string length limit in GDI on NT.
+	maxLenText = 65535;
 
 	codePage = 0;
-	win9xACPSame = false;
 }
 
 SurfaceGDI::~SurfaceGDI() {
@@ -909,7 +900,7 @@ void SurfaceGDI::DrawTextCommon(PRectangle rc, Font &font_, XYPOSITION ybase, co
 	// If it does fail, slice up into segments and draw each segment.
 	const int maxSegmentLength = 0x200;
 
-	if ((!unicodeMode) && (IsNT() || (codePage==0) || win9xACPSame)) {
+	if (!unicodeMode) {
 		// Use ANSI calls
 		int lenDraw = Platform::Minimum(len, maxLenText);
 		if (!::ExtTextOutA(hdc, x, yBaseInt, fuOptions, &rcw, s, lenDraw, NULL)) {
@@ -973,7 +964,7 @@ void SurfaceGDI::DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybas
 XYPOSITION SurfaceGDI::WidthText(Font &font_, const char *s, int len) {
 	SetFont(font_);
 	SIZE sz={0,0};
-	if ((!unicodeMode) && (IsNT() || (codePage==0) || win9xACPSame)) {
+	if (!unicodeMode) {
 		::GetTextExtentPoint32A(hdc, s, Platform::Minimum(len, maxLenText), &sz);
 	} else {
 		const TextWide tbuf(s, len, unicodeMode, codePage);
@@ -1025,7 +1016,7 @@ void SurfaceGDI::MeasureWidths(Font &font_, const char *s, int len, XYPOSITION *
 		while (i<len) {
 			positions[i++] = lastPos;
 		}
-	} else if (IsNT() || (codePage==0) || win9xACPSame) {
+	} else {
 		// Zero positions to avoid random behaviour on failure.
 		std::fill(positions, positions + len, 0.0f);
 		// len may be larger than platform supports so loop over segments small enough for platform
@@ -1051,28 +1042,6 @@ void SurfaceGDI::MeasureWidths(Font &font_, const char *s, int len, XYPOSITION *
 			positions += lenBlock;
 			s += lenBlock;
 		}
-	} else {
-		// Support Asian string display in 9x English
-		const TextWide tbuf(s, len, unicodeMode, codePage);
-		TextPositionsI poses(tbuf.tlen);
-		for (int widthSS=0; widthSS<tbuf.tlen; widthSS++) {
-			::GetTextExtentPoint32W(hdc, tbuf.buffer, widthSS+1, &sz);
-			poses.buffer[widthSS] = sz.cx;
-		}
-
-		int ui = 0;
-		for (int i=0; i<len;) {
-			if (Platform::IsDBCSLeadByte(codePage, s[i])) {
-				positions[i] = static_cast<XYPOSITION>(poses.buffer[ui]);
-				positions[i + 1] = static_cast<XYPOSITION>(poses.buffer[ui]);
-				i += 2;
-			} else {
-				positions[i] = static_cast<XYPOSITION>(poses.buffer[ui]);
-				i++;
-			}
-
-			ui++;
-		}
 	}
 }
 
@@ -1143,7 +1112,6 @@ void SurfaceGDI::SetUnicodeMode(bool unicodeMode_) {
 void SurfaceGDI::SetDBCSMode(int codePage_) {
 	// No action on window as automatically handled by system.
 	codePage = codePage_;
-	win9xACPSame = !IsNT() && ((unsigned int)codePage == ::GetACP());
 }
 
 #if defined(USE_D2D)
@@ -3258,9 +3226,6 @@ int Platform::Clamp(int val, int minVal, int maxVal) {
 #endif
 
 void Platform_Initialise(void *hInstance) {
-	OSVERSIONINFO osv = {sizeof(OSVERSIONINFO),0,0,0,0,TEXT("")};
-	::GetVersionEx(&osv);
-	onNT = osv.dwPlatformId == VER_PLATFORM_WIN32_NT;
 	::InitializeCriticalSection(&crPlatformLock);
 	hinstPlatformRes = reinterpret_cast<HINSTANCE>(hInstance);
 	// This may be called from DllMain, in which case the call to LoadLibrary
diff --git a/ext/scintilla/win32/PlatWin.h b/ext/scintilla/win32/PlatWin.h
index c93df4dc0..417c656f2 100644
--- a/ext/scintilla/win32/PlatWin.h
+++ b/ext/scintilla/win32/PlatWin.h
@@ -12,7 +12,6 @@
 namespace Scintilla {
 #endif
 
-extern bool IsNT();
 extern void Platform_Initialise(void *hInstance);
 extern void Platform_Finalise(bool fromDllMain);
 
diff --git a/ext/scintilla/win32/ScintRes.rc b/ext/scintilla/win32/ScintRes.rc
index 0f7ced08a..c68ee422b 100644
--- a/ext/scintilla/win32/ScintRes.rc
+++ b/ext/scintilla/win32/ScintRes.rc
@@ -4,8 +4,8 @@
 
 #include <windows.h>
 
-#define VERSION_SCINTILLA "3.5.2"
-#define VERSION_WORDS 3, 5, 2, 0
+#define VERSION_SCINTILLA "3.5.3"
+#define VERSION_WORDS 3, 5, 3, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
diff --git a/ext/scintilla/win32/ScintillaWin.cxx b/ext/scintilla/win32/ScintillaWin.cxx
index cc4e9c27a..211b8d468 100644
--- a/ext/scintilla/win32/ScintillaWin.cxx
+++ b/ext/scintilla/win32/ScintillaWin.cxx
@@ -103,6 +103,11 @@
 
 #define SC_WIN_IDLE 5001
 
+#define SC_INDICATOR_INPUT INDIC_IME
+#define SC_INDICATOR_TARGET INDIC_IME+1
+#define SC_INDICATOR_CONVERTED INDIC_IME+2
+#define SC_INDICATOR_UNKNOWN INDIC_IME_MAX
+
 typedef BOOL (WINAPI *TrackMouseEventSig)(LPTRACKMOUSEEVENT);
 typedef UINT_PTR (WINAPI *SetCoalescableTimerSig)(HWND hwnd, UINT_PTR nIDEvent,
 	UINT uElapse, TIMERPROC lpTimerFunc, ULONG uToleranceDelay);
@@ -239,9 +244,14 @@ class ScintillaWin :
 	virtual bool DragThreshold(Point ptStart, Point ptNow);
 	virtual void StartDrag();
 	sptr_t WndPaint(uptr_t wParam);
-	sptr_t HandleComposition(uptr_t wParam, sptr_t lParam);
+
+	sptr_t HandleCompositionWindowed(uptr_t wParam, sptr_t lParam);
+	sptr_t HandleCompositionInline(uptr_t wParam, sptr_t lParam);
 	static bool KoreanIME();
-	sptr_t HandleCompositionKoreanIME(uptr_t wParam, sptr_t lParam);
+	void MoveImeCarets(int offset);
+	void DrawImeIndicator(int indicator, int len);
+	void SetCandidateWindowPos();
+
 	UINT CodePageOfDocument();
 	virtual bool ValidCodePage(int codePage) const;
 	virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
@@ -265,7 +275,6 @@ class ScintillaWin :
 	virtual void SetCtrlID(int identifier);
 	virtual int GetCtrlID();
 	virtual void NotifyParent(SCNotification scn);
-	virtual void NotifyParent(SCNotification * scn);
 	virtual void NotifyDoubleClick(Point pt, int modifiers);
 	virtual CaseFolder *CaseFolderForEncoding();
 	virtual std::string CaseMapString(const std::string &s, int caseMapping);
@@ -423,6 +432,10 @@ void ScintillaWin::Initialise() {
 	for (TickReason tr = tickCaret; tr <= tickDwell; tr = static_cast<TickReason>(tr + 1)) {
 		timers[tr] = 0;
 	}
+	vs.indicators[SC_INDICATOR_UNKNOWN] = Indicator(INDIC_HIDDEN, ColourDesired(0, 0, 0xff));
+	vs.indicators[SC_INDICATOR_INPUT] = Indicator(INDIC_DOTS, ColourDesired(0, 0, 0xff));
+	vs.indicators[SC_INDICATOR_CONVERTED] = Indicator(INDIC_COMPOSITIONTHICK, ColourDesired(0, 0, 0xff));
+	vs.indicators[SC_INDICATOR_TARGET] = Indicator(INDIC_STRAIGHTBOX, ColourDesired(0, 0, 0xff));
 }
 
 void ScintillaWin::Finalise() {
@@ -472,10 +485,12 @@ void ScintillaWin::EnsureRenderTarget(HDC hdc) {
 
 			ID2D1DCRenderTarget *pDCRT = NULL;
 			HRESULT hr = pD2DFactory->CreateDCRenderTarget(&drtp, &pDCRT);
-			if (FAILED(hr)) {
+			if (SUCCEEDED(hr)) {
+				pRenderTarget = pDCRT;
+			} else {
 				Platform::DebugPrintf("Failed CreateDCRenderTarget 0x%x\n", hr);
+				pRenderTarget = NULL;
 			}
-			pRenderTarget = pDCRT;
 
 		} else {
 			D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp;
@@ -486,10 +501,12 @@ void ScintillaWin::EnsureRenderTarget(HDC hdc) {
 
 			ID2D1HwndRenderTarget *pHwndRenderTarget = NULL;
 			HRESULT hr = pD2DFactory->CreateHwndRenderTarget(drtp, dhrtp, &pHwndRenderTarget);
-			if (FAILED(hr)) {
+			if (SUCCEEDED(hr)) {
+				pRenderTarget = pHwndRenderTarget;
+			} else {
 				Platform::DebugPrintf("Failed CreateHwndRenderTarget 0x%x\n", hr);
+				pRenderTarget = NULL;
 			}
-			pRenderTarget = pHwndRenderTarget;
 		}
 #else
 		pD2DFactory->CreateHwndRenderTarget(
@@ -505,7 +522,7 @@ void ScintillaWin::EnsureRenderTarget(HDC hdc) {
 		DropGraphics(false);
 	}
 
-	if (technology == SC_TECHNOLOGY_DIRECTWRITEDC) {
+	if ((technology == SC_TECHNOLOGY_DIRECTWRITEDC) && pRenderTarget) {
 		RECT rcWindow;
 		GetClientRect(MainHWND(), &rcWindow);
 		HRESULT hr = static_cast<ID2D1DCRenderTarget*>(pRenderTarget)->BindDC(hdc, &rcWindow);
@@ -706,7 +723,7 @@ LRESULT ScintillaWin::WndPaint(uptr_t wParam) {
 	return 0l;
 }
 
-sptr_t ScintillaWin::HandleComposition(uptr_t wParam, sptr_t lParam) {
+sptr_t ScintillaWin::HandleCompositionWindowed(uptr_t wParam, sptr_t lParam) {
 	if (lParam & GCS_RESULTSTR) {
 		HIMC hIMC = ::ImmGetContext(MainHWND());
 		if (hIMC) {
@@ -747,89 +764,167 @@ bool ScintillaWin::KoreanIME() {
 	return codePage == 949 || codePage == 1361;
 }
 
-sptr_t ScintillaWin::HandleCompositionKoreanIME(uptr_t, sptr_t lParam) {
+void ScintillaWin::MoveImeCarets(int offset) {
+	// Move carets relatively by bytes.
+	for (size_t r=0; r<sel.Count(); r++) {
+		int positionInsert = sel.Range(r).Start().Position();
+		sel.Range(r).caret.SetPosition(positionInsert + offset);
+		sel.Range(r).anchor.SetPosition(positionInsert + offset);
+	}
+}
 
-	// copy & paste by johnsonj
-	// Great thanks to
-	// jiniya from http://www.jiniya.net/tt/494  for DBCS input with AddCharUTF()
-	// BLUEnLIVE from http://zockr.tistory.com/1118 for UNDO and inOverstrike
+void ScintillaWin::DrawImeIndicator(int indicator, int len) {
+	// Emulate the visual style of IME characters with indicators.
+	// Draw an indicator on the character before caret by the character bytes of len
+	// so it should be called after addCharUTF().
+	// It does not affect caret positions.
+	if (indicator < 8 || indicator > INDIC_MAX) {
+		return;
+	}
+	pdoc->decorations.SetCurrentIndicator(indicator);
+	for (size_t r=0; r<sel.Count(); r++) {
+		int positionInsert = sel.Range(r).Start().Position();
+		pdoc->DecorationFillRange(positionInsert - len, 1, len);
+	}
+}
+
+void ScintillaWin::SetCandidateWindowPos() {
+	HIMC hIMC = ::ImmGetContext(MainHWND());
+	if (hIMC) {
+		Point pos = PointMainCaret();
+		CANDIDATEFORM CandForm;
+		CandForm.dwIndex = 0;
+		CandForm.dwStyle = CFS_CANDIDATEPOS;
+		CandForm.ptCurrentPos.x = static_cast<int>(pos.x);
+		CandForm.ptCurrentPos.y = static_cast<int>(pos.y + vs.lineHeight);
+		::ImmSetCandidateWindow(hIMC, &CandForm);
+		::ImmReleaseContext(MainHWND(), hIMC);
+	}
+}
+
+sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
+	// Copy & paste by johnsonj with a lot of helps of Neil.
+	// Great thanks for my foreruners, jiniya and BLUEnLIVE.
 
 	HIMC hIMC = ::ImmGetContext(MainHWND());
 	if (!hIMC) {
 		return 0;
 	}
 
-	wchar_t wcs[maxLenInputIME];
-	int wides = 0;
-	bool compstrExist = false;
-
 	if (pdoc->TentativeActive()) {
 		pdoc->TentativeUndo();
 	} else {
 		// No tentative undo means start of this composition so
 		// fill in any virtual spaces.
-		bool tmpOverstrike = inOverstrike;
-		inOverstrike = false;         // not allow to be deleted twice.
-		AddCharUTF("", 0);
-		inOverstrike = tmpOverstrike;
+		FillVirtualSpace();
 	}
 
 	view.imeCaretBlockOverride = false;
+
 	if (lParam & GCS_COMPSTR) {
+		wchar_t wcs[maxLenInputIME] = { 0 };
 		long bytes = ::ImmGetCompositionStringW
-						   (hIMC, GCS_COMPSTR, wcs, maxLenInputIME);
-		wides = bytes / 2;
-		compstrExist = (wides != 0);
-	} else if (lParam & GCS_RESULTSTR) {
-		long bytes = ::ImmGetCompositionStringW
-						(hIMC, GCS_RESULTSTR, wcs, maxLenInputIME);
-		wides = bytes / 2;
-		compstrExist = (wides == 0);
-	}
+			(hIMC, GCS_COMPSTR, wcs, maxLenInputIME);
+		unsigned int wcsLen = bytes / 2;
+
+		if ((wcsLen == 0) || (wcsLen >= maxLenInputIME)) {
+			ShowCaretAtCurrentPosition();
+			::ImmReleaseContext(MainHWND(), hIMC);
+			return 0;
+		}
 
-	if (wides >= 1) {
+		pdoc->TentativeStart(); // TentativeActive from now on.
 
-		char hanval[maxLenInputIME];
-		unsigned int hanlen = 0;
+		// Get attribute information from composition string.
+		BYTE compAttr[maxLenInputIME] = { 0 };
+		unsigned int imeCursorPos = 0;
 
-		if (IsUnicodeMode()) {
-			hanlen = UTF8Length(wcs, wides);
-			UTF8FromUTF16(wcs, wides, hanval, hanlen);
-			hanval[hanlen] = '\0';
-		} else {
-			hanlen = ::WideCharToMultiByte(InputCodePage(), 0,
-						wcs, wides, hanval, sizeof(hanval) - 1, 0, 0);
-			hanval[hanlen] = '\0';
+		if (lParam & GCS_COMPATTR) {
+			ImmGetCompositionStringW(hIMC, GCS_COMPATTR, compAttr, sizeof(compAttr));
+		}
+		if (lParam & GCS_CURSORPOS) {
+			imeCursorPos = ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, NULL, 0);
 		}
 
-		if (compstrExist) {
-			view.imeCaretBlockOverride = true;
+		// Display character by character.
+		int numBytes = 0;
+		int imeCharPos[maxLenInputIME + 1] = { 0 };
+
+		bool tmpRecordingMacro = recordingMacro;
+		recordingMacro = false;
+		for (unsigned int i = 0; i < wcsLen; i++) {
+			wchar_t uniChar[1] = { 0 };
+			char oneChar[UTF8MaxBytes + 1] = "\0\0\0\0"; // Maximum 4 bytes in utf8
+			unsigned int oneCharLen = 0;
+
+			uniChar[0] = wcs[i];
 
-			bool tmpRecordingMacro = recordingMacro;
-			recordingMacro = false;
-			pdoc->TentativeStart();
-			AddCharUTF(hanval, hanlen);
-			recordingMacro = tmpRecordingMacro;
+			if (IsUnicodeMode()) {
+				oneCharLen = UTF8Length(uniChar, 1);
+				UTF8FromUTF16(uniChar, 1, oneChar, oneCharLen);
+				oneChar[oneCharLen] = '\0';
+			} else {
+				oneCharLen = ::WideCharToMultiByte(InputCodePage(), 0,
+					uniChar, 1, oneChar, sizeof(oneChar)-1, 0, 0);
+				oneChar[oneCharLen] = '\0';
+			}
+
+			// Display a character.
+			AddCharUTF(oneChar, oneCharLen);
+
+			// Record compstr character positions for moving IME carets.
+			numBytes += oneCharLen;
+			imeCharPos[i + 1] = numBytes;
 
-			for (size_t r = 0; r < sel.Count(); r++) { // for block caret
-				int positionInsert = sel.Range(r).Start().Position();
-				sel.Range(r).caret.SetPosition(positionInsert - hanlen);
-				sel.Range(r).anchor.SetPosition(positionInsert - hanlen);
+			// Draw an indicator on the character.
+			int indicator = SC_INDICATOR_UNKNOWN;
+			switch ((int)compAttr[i]) {
+			case ATTR_INPUT:
+				indicator = SC_INDICATOR_INPUT;
+				break;
+			case ATTR_TARGET_NOTCONVERTED:
+			case ATTR_TARGET_CONVERTED:
+				indicator = SC_INDICATOR_TARGET;
+				break;
+			case ATTR_CONVERTED:
+				indicator = SC_INDICATOR_CONVERTED;
+				break;
 			}
-		} else {
-			AddCharUTF(hanval, hanlen);
+			DrawImeIndicator(indicator, oneCharLen);
 		}
-	}
+		recordingMacro = tmpRecordingMacro;
+
+		// Move IME caret position.
+		MoveImeCarets(-imeCharPos[wcsLen] + imeCharPos[imeCursorPos]);
+		if (KoreanIME()) {
+			view.imeCaretBlockOverride = true;
+		}
+	} else if (lParam & GCS_RESULTSTR) {
+		wchar_t wcs[maxLenInputIME] = { 0 };
+		long bytes = ::ImmGetCompositionStringW
+			(hIMC, GCS_RESULTSTR, wcs, maxLenInputIME);
+		unsigned int wcsLen = bytes / 2;
 
-	// set the candidate window position for HANJA while composing.
-	Point pos = PointMainCaret();
-	CANDIDATEFORM CandForm;
-	CandForm.dwIndex = 0;
-	CandForm.dwStyle = CFS_CANDIDATEPOS;
-	CandForm.ptCurrentPos.x = static_cast<int>(pos.x);
-	CandForm.ptCurrentPos.y = static_cast<int>(pos.y + vs.lineHeight);
-	::ImmSetCandidateWindow(hIMC, &CandForm);
+		for (unsigned int i = 0; i < wcsLen; i++) {
+			wchar_t uniChar[1] = { 0 };
+			char oneChar[UTF8MaxBytes+1] = "\0\0\0\0"; // Maximum 4 bytes in UTF-8.
+			unsigned int oneCharLen = 0;
 
+			uniChar[0] = wcs[i];
+
+			if (IsUnicodeMode()) {
+				oneCharLen = UTF8Length(uniChar, 1);
+				UTF8FromUTF16(uniChar, 1, oneChar, oneCharLen);
+				oneChar[oneCharLen] = '\0';
+			} else {
+				oneCharLen = ::WideCharToMultiByte(InputCodePage(), 0,
+					uniChar, 1, oneChar, sizeof(oneChar)-1, 0, 0);
+				oneChar[oneCharLen] = '\0';
+			}
+			AddCharUTF(oneChar, oneCharLen);
+		}
+	}
+	SetCandidateWindowPos();
 	ShowCaretAtCurrentPosition();
 	::ImmReleaseContext(MainHWND(), hIMC);
 	return 0;
@@ -925,12 +1020,12 @@ sptr_t ScintillaWin::GetText(uptr_t wParam, sptr_t lParam) {
 		std::vector<char> docBytes(pdoc->Length(), '\0');
 		pdoc->GetCharRange(&docBytes[0], 0, pdoc->Length());
 		if (IsUnicodeMode()) {
-			unsigned int lengthUTF16 = UTF16Length(&docBytes[0], static_cast<unsigned int>(docBytes.size()));
+			size_t lengthUTF16 = UTF16Length(&docBytes[0], static_cast<unsigned int>(docBytes.size()));
 			if (lParam == 0)
 				return lengthUTF16;
 			if (wParam == 0)
 				return 0;
-			unsigned int uLen = UTF16FromUTF8(&docBytes[0], static_cast<unsigned int>(docBytes.size()),
+			size_t uLen = UTF16FromUTF8(&docBytes[0], docBytes.size(),
 				ptr, static_cast<int>(wParam) - 1);
 			ptr[uLen] = L'\0';
 			return uLen;
@@ -1279,21 +1374,22 @@ sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 			break;
 
 		case WM_IME_STARTCOMPOSITION: 	// dbcs
-			if (KoreanIME()) {
+			if (KoreanIME() || imeInteraction == imeInline) {
 				return 0;
+			} else {
+				ImeStartComposition();
+				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 			}
-			ImeStartComposition();
-			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
 		case WM_IME_ENDCOMPOSITION: 	// dbcs
 			ImeEndComposition();
 			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
 		case WM_IME_COMPOSITION:
-			if (KoreanIME()) {
-				return HandleCompositionKoreanIME(wParam, lParam);
+			if (KoreanIME() || imeInteraction == imeInline) { 
+				return HandleCompositionInline(wParam, lParam);
 			} else {
-				return HandleComposition(wParam, lParam);
+				return HandleCompositionWindowed(wParam, lParam);
 			}
 
 		case WM_IME_CHAR: {
@@ -1331,7 +1427,7 @@ sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 			return 0;
 
 		case WM_IME_SETCONTEXT:
-			if (KoreanIME()) {
+			if (KoreanIME() || imeInteraction == imeInline) {
 				if (wParam) {
 					LPARAM NoImeWin = lParam;
 					NoImeWin = NoImeWin & (~ISC_SHOWUICOMPOSITIONWINDOW);
@@ -1704,13 +1800,6 @@ void ScintillaWin::NotifyParent(SCNotification scn) {
 	              GetCtrlID(), reinterpret_cast<LPARAM>(&scn));
 }
 
-void ScintillaWin::NotifyParent(SCNotification * scn) {
-	scn->nmhdr.hwndFrom = MainHWND();
-	scn->nmhdr.idFrom = GetCtrlID();
-	::SendMessage(::GetParent(MainHWND()), WM_NOTIFY,
-		GetCtrlID(), reinterpret_cast<LPARAM>(scn));
-}
-
 void ScintillaWin::NotifyDoubleClick(Point pt, int modifiers) {
 	//Platform::DebugPrintf("ScintillaWin Double click 0\n");
 	ScintillaBase::NotifyDoubleClick(pt, modifiers);
@@ -1758,8 +1847,8 @@ public:
 				if (foldedUTF8) {
 					// Maximum length of a case conversion is 6 bytes, 3 characters
 					wchar_t wFolded[20];
-					unsigned int charsConverted = UTF16FromUTF8(foldedUTF8,
-							static_cast<unsigned int>(strlen(foldedUTF8)),
+					size_t charsConverted = UTF16FromUTF8(foldedUTF8,
+							strlen(foldedUTF8),
 							wFolded, ELEMENTS(wFolded));
 					for (size_t j=0; j<charsConverted; j++)
 						utf16Folded[lenFlat++] = wFolded[j];
@@ -1804,13 +1893,13 @@ CaseFolder *ScintillaWin::CaseFolderForEncoding() {
 					const char *caseFolded = CaseConvert(wCharacter[0], CaseConversionFold);
 					if (caseFolded) {
 						wchar_t wLower[20];
-						unsigned int charsConverted = UTF16FromUTF8(caseFolded,
-							static_cast<unsigned int>(strlen(caseFolded)),
+						size_t charsConverted = UTF16FromUTF8(caseFolded,
+							strlen(caseFolded),
 							wLower, ELEMENTS(wLower));
 						if (charsConverted == 1) {
 							char sCharacterLowered[20];
 							unsigned int lengthConverted = ::WideCharToMultiByte(cpDoc, 0,
-								wLower, charsConverted,
+								wLower, static_cast<int>(charsConverted),
 								sCharacterLowered, ELEMENTS(sCharacterLowered), NULL, 0);
 							if ((lengthConverted == 1) && (sCharacter[0] != sCharacterLowered[0])) {
 								pcf->SetTranslation(sCharacter[0], sCharacterLowered[0]);
@@ -1908,8 +1997,10 @@ public:
 	}
 	~GlobalMemory() {
 		PLATFORM_ASSERT(!ptr);
+		assert(!hand);
 	}
 	void Allocate(size_t bytes) {
+		assert(!hand);
 		hand = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, bytes);
 		if (hand) {
 			ptr = ::GlobalLock(hand);
@@ -2382,11 +2473,12 @@ void ScintillaWin::ImeStartComposition() {
 			lf.lfWeight = vs.styles[styleHere].weight;
 			lf.lfItalic = static_cast<BYTE>(vs.styles[styleHere].italic ? 1 : 0);
 			lf.lfCharSet = DEFAULT_CHARSET;
-			lf.lfFaceName[0] = '\0';
+			lf.lfFaceName[0] = L'\0';
 			if (vs.styles[styleHere].fontName) {
 				const char* fontName = vs.styles[styleHere].fontName;
 				UTF16FromUTF8(fontName, strlen(fontName)+1, lf.lfFaceName, LF_FACESIZE);
 			}
+
 			::ImmSetCompositionFontW(hIMC, &lf);
 		}
 		::ImmReleaseContext(MainHWND(), hIMC);
@@ -2446,11 +2538,11 @@ void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
 
 	// Default Scintilla behaviour in Unicode mode
 	if (IsUnicodeMode()) {
-		int uchars = UTF16Length(selectedText.Data(),
+		size_t uchars = UTF16Length(selectedText.Data(),
 			static_cast<int>(selectedText.LengthWithTerminator()));
 		uniText.Allocate(2 * uchars);
 		if (uniText) {
-			UTF16FromUTF8(selectedText.Data(), static_cast<int>(selectedText.LengthWithTerminator()),
+			UTF16FromUTF8(selectedText.Data(), selectedText.LengthWithTerminator(),
 				static_cast<wchar_t *>(uniText.ptr), uchars);
 		}
 	} else {
@@ -2469,20 +2561,6 @@ void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
 	}
 
 	if (uniText) {
-		if (!IsNT()) {
-			// Copy ANSI text to clipboard on Windows 9x
-			// Convert from Unicode text, so other ANSI programs can
-			// paste the text
-			// Windows NT, 2k, XP automatically generates CF_TEXT
-			GlobalMemory ansiText;
-			ansiText.Allocate(selectedText.LengthWithTerminator());
-			if (ansiText) {
-				::WideCharToMultiByte(CP_ACP, 0, static_cast<wchar_t *>(uniText.ptr), -1,
-					static_cast<char *>(ansiText.ptr),
-					static_cast<int>(selectedText.LengthWithTerminator()), NULL, NULL);
-				ansiText.SetClip(CF_TEXT);
-			}
-		}
 		uniText.SetClip(CF_UNICODETEXT);
 	} else {
 		// There was a failure - try to copy at least ANSI text
@@ -2837,10 +2915,10 @@ STDMETHODIMP ScintillaWin::GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) {
 
 	GlobalMemory text;
 	if (pFEIn->cfFormat == CF_UNICODETEXT) {
-		int uchars = UTF16Length(drag.Data(), static_cast<int>(drag.LengthWithTerminator()));
+		size_t uchars = UTF16Length(drag.Data(), static_cast<int>(drag.LengthWithTerminator()));
 		text.Allocate(2 * uchars);
 		if (text) {
-			UTF16FromUTF8(drag.Data(), static_cast<int>(drag.LengthWithTerminator()),
+			UTF16FromUTF8(drag.Data(), drag.LengthWithTerminator(),
 				static_cast<wchar_t *>(text.ptr), uchars);
 		}
 	} else {
@@ -2860,43 +2938,22 @@ bool ScintillaWin::Register(HINSTANCE hInstance_) {
 	bool result;
 
 	// Register the Scintilla class
-	if (IsNT()) {
-
-		// Register Scintilla as a wide character window
-		WNDCLASSEXW wndclass;
-		wndclass.cbSize = sizeof(wndclass);
-		wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-		wndclass.lpfnWndProc = ScintillaWin::SWndProc;
-		wndclass.cbClsExtra = 0;
-		wndclass.cbWndExtra = sizeof(ScintillaWin *);
-		wndclass.hInstance = hInstance;
-		wndclass.hIcon = NULL;
-		wndclass.hCursor = NULL;
-		wndclass.hbrBackground = NULL;
-		wndclass.lpszMenuName = NULL;
-		wndclass.lpszClassName = L"Scintilla";
-		wndclass.hIconSm = 0;
-		scintillaClassAtom = ::RegisterClassExW(&wndclass);
-		result = 0 != scintillaClassAtom;
-	} else {
-
-		// Register Scintilla as a normal character window
-		WNDCLASSEX wndclass;
-		wndclass.cbSize = sizeof(wndclass);
-		wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-		wndclass.lpfnWndProc = ScintillaWin::SWndProc;
-		wndclass.cbClsExtra = 0;
-		wndclass.cbWndExtra = sizeof(ScintillaWin *);
-		wndclass.hInstance = hInstance;
-		wndclass.hIcon = NULL;
-		wndclass.hCursor = NULL;
-		wndclass.hbrBackground = NULL;
-		wndclass.lpszMenuName = NULL;
-		wndclass.lpszClassName = scintillaClassName;
-		wndclass.hIconSm = 0;
-		scintillaClassAtom = ::RegisterClassEx(&wndclass);
-		result = 0 != scintillaClassAtom;
-	}
+	// Register Scintilla as a wide character window
+	WNDCLASSEXW wndclass;
+	wndclass.cbSize = sizeof(wndclass);
+	wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
+	wndclass.lpfnWndProc = ScintillaWin::SWndProc;
+	wndclass.cbClsExtra = 0;
+	wndclass.cbWndExtra = sizeof(ScintillaWin *);
+	wndclass.hInstance = hInstance;
+	wndclass.hIcon = NULL;
+	wndclass.hCursor = NULL;
+	wndclass.hbrBackground = NULL;
+	wndclass.lpszMenuName = NULL;
+	wndclass.lpszClassName = L"Scintilla";
+	wndclass.hIconSm = 0;
+	scintillaClassAtom = ::RegisterClassExW(&wndclass);
+	result = 0 != scintillaClassAtom;
 
 	if (result) {
 		// Register the CallTip class
diff --git a/ext/scintilla/win32/scintilla.mak b/ext/scintilla/win32/scintilla.mak
index 6573e66f5..86c6b3878 100644
--- a/ext/scintilla/win32/scintilla.mak
+++ b/ext/scintilla/win32/scintilla.mak
@@ -136,6 +136,7 @@ LEXOBJS=\
 	$(DIR_O)\LexGAP.obj \
 	$(DIR_O)\LexGui4Cli.obj \
 	$(DIR_O)\LexHaskell.obj \
+	$(DIR_O)\LexHex.obj \
 	$(DIR_O)\LexHTML.obj \
 	$(DIR_O)\LexInno.obj \
 	$(DIR_O)\LexKix.obj \
@@ -530,6 +531,8 @@ $(DIR_O)\LexGui4Cli.obj: ..\lexers\LexGui4Cli.cxx $(LEX_HEADERS)
 
 $(DIR_O)\LexHaskell.obj: ..\lexers\LexHaskell.cxx $(LEX_HEADERS)
 
+$(DIR_O)\LexHex.obj: ..\lexers\LexHex.cxx $(LEX_HEADERS)
+
 $(DIR_O)\LexHTML.obj: ..\lexers\LexHTML.cxx $(LEX_HEADERS)
 
 $(DIR_O)\LexInno.obj: ..\lexers\LexInno.cxx $(LEX_HEADERS)
diff --git a/ext/scintilla/zipsrc.bat b/ext/scintilla/zipsrc.bat
deleted file mode 100644
index 9d6d08b55..000000000
--- a/ext/scintilla/zipsrc.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-cd ..
-del/q scintilla.zip
-zip scintilla.zip scintilla\*.* scintilla\*\*.* scintilla\*\*\*.* scintilla\*\*\*\*.* scintilla\*\*\*\*\*.* -x *.o -x *.obj -x *.dll -x *.lib -x *.res -x *.exp
-cd scintilla
-- 
2.11.4.GIT