[UPDATE] Update Scintilla from 2.12 to 2.20

git-svn-id: svn://svn.tuxfamily.org/svnroot/notepadplus/repository/trunk@653 f5eea248-9336-0410-98b8-ebc06183d4e3
2010-08-21 23:59:56 +00:00 · 2010-08-21 23:59:56 +00:00 · d4d42f8a1a
commit d4d42f8a1a
parent 46c3286077
188 changed files with 13919 additions and 10468 deletions
--- a/scintilla/cocoa/Framework.mk
+++ b/scintilla/cocoa/Framework.mk
@ -1,49 +1,51 @@
 ### start defines ###
+include common.mk

-ARCH=-arch i386
-CC=gcc -x c++ $(ARCH)
-CO=gcc -x objective-c++ $(ARCH)
+INST_NAME=-install_name \
+	@executable_path/../Frameworks/Sci.framework/Versions/A/Sci

-INST_NAME=-install_name @executable_path/../Frameworks/Sci.framework/Versions/A/Sci
 LD=gcc $(ARCH) -dynamiclib -framework Cocoa $(INST_NAME)

-gDEFs=-DSCI_NAMESPACE -DSCI_LEXER
+SCI_LEXERS=LexAPDL.o LexASY.o LexAU3.o LexAVE.o LexAbaqus.o LexAda.o \
+	LexAsm.o LexAsn1.o LexBaan.o LexBash.o LexBasic.o LexBullant.o LexCLW.o \
+	LexCOBOL.o LexCPP.o LexCSS.o LexCaml.o LexCmake.o LexConf.o LexCrontab.o \
+	LexCsound.o LexD.o LexEScript.o LexEiffel.o LexErlang.o LexFlagship.o \
+	LexForth.o LexFortran.o LexGAP.o LexGui4Cli.o LexHTML.o LexHaskell.o \
+	LexInno.o LexKix.o LexLisp.o LexLout.o LexLua.o LexMMIXAL.o LexMPT.o \
+	LexMSSQL.o LexMagik.o LexMarkdown.o LexMatlab.o LexMetapost.o LexMySQL.o \
+	LexNimrod.o LexNsis.o LexOpal.o LexOthers.o LexPB.o LexPLM.o LexPOV.o \
+	LexPS.o LexPascal.o LexPerl.o LexPowerPro.o LexPowerShell.o LexProgress.o \
+	LexPython.o LexR.o LexRebol.o LexRuby.o LexSML.o LexSQL.o LexScriptol.o \
+	LexSmalltalk.o LexSorcus.o LexSpecman.o LexSpice.o LexTACL.o LexTADS3.o \
+	LexTAL.o LexTCL.o LexTeX.o LexVB.o LexVHDL.o LexVerilog.o LexYAML.o \
+	LexerBase.o LexerModule.o LexerSimple.o Accessor.o

-INCS=-I../src/ -I../include/ -I.
-CCX=$(CC) $(gDEFs) $(INCS)
-CCO=$(CO) $(gDEFs) $(INCS)
+SCI_OBJ=AutoComplete.o CallTip.o CellBuffer.o CharClassify.o \
+	ContractionState.o Decoration.o Document.o Editor.o \
+	ExternalLexer.o Indicator.o KeyMap.o LineMarker.o PerLine.o \
+	PositionCache.o PropSetSimple.o RESearch.o RunStyles.o ScintillaBase.o Style.o \
+	StyleContext.o UniConversion.o ViewStyle.o XPM.o WordList.o \
+	Selection.o CharacterSet.o Catalogue.o $(SCI_LEXERS)	

-BLD=build/framebuild
+WAH_OBJ=DocumentAccessor.o KeyWords.o WindowAccessor.o

-SCI_LEXERS=LexAPDL.o LexASY.o LexAU3.o LexAVE.o LexAbaqus.o LexAda.o LexAsm.o LexAsn1.o \
-	LexBaan.o LexBash.o LexBasic.o LexBullant.o LexCLW.o LexCOBOL.o LexCPP.o LexCSS.o \
-	LexCaml.o LexCmake.o LexConf.o LexCrontab.o LexCsound.o LexD.o LexEScript.o LexEiffel.o \
-	LexErlang.o LexFlagship.o LexForth.o LexFortran.o LexGAP.o LexGui4Cli.o LexHTML.o \
-	LexHaskell.o LexInno.o LexKix.o LexLisp.o LexLout.o LexLua.o LexMMIXAL.o LexMPT.o \
-	LexMSSQL.o LexMagik.o LexMarkdown.o LexMatlab.o LexMetapost.o LexMySQL.o LexNimrod.o \
-	LexNsis.o LexOpal.o LexOthers.o LexPB.o LexPLM.o LexPOV.o LexPS.o LexPascal.o LexPerl.o \
-	LexPowerPro.o LexPowerShell.o LexProgress.o LexPython.o LexR.o LexRebol.o LexRuby.o \
-	LexSML.o LexSQL.o LexScriptol.o LexSmalltalk.o LexSorcus.o LexSpecman.o LexSpice.o \
-	LexTACL.o LexTADS3.o LexTAL.o LexTCL.o LexTeX.o LexVB.o LexVHDL.o LexVerilog.o LexYAML.o
-
-SCI_OBJ=AutoComplete.o CallTip.o CellBuffer.o CharClassify.o ContractionState.o Decoration.o \
-	Document.o DocumentAccessor.o Editor.o ExternalLexer.o Indicator.o KeyMap.o KeyWords.o \
-	LineMarker.o PerLine.o PositionCache.o PropSet.o RESearch.o RunStyles.o ScintillaBase.o \
-	Style.o StyleContext.o UniConversion.o ViewStyle.o WindowAccessor.o XPM.o Selection.o $(SCI_LEXERS)
 COC_OBJ=PlatCocoa.o ScintillaCocoa.o ScintillaView.o InfoBar.o

-OBJ=$(SCI_OBJ) $(COC_OBJ)
-OBJS=$(addprefix $(BLD)/,$(OBJ))
+OBJ=$(SCI_OBJ) $(UNUSED_OBJ) $(COC_OBJ)
+OBJS=$(addprefix $(FRM_BLD)/,$(OBJ))

 TARG=$(APP)/Versions/A/Sci
-APP=$(BLD)/Sci.framework
+APP=$(FRM_BLD)/Sci.framework
 ### end defines ###

 ### start targets ###

-all: $(BLD) $(TARG)
+all: $(FRM_BLD) $(TARG)

-$(APP): $(BLD)
+cleanfrm:
+	-rm -rf $(FRM_BLD)
+
+$(APP): $(FRM_BLD)
 	-rm -rf $(APP)
 	-mkdir $(APP)
 	-mkdir $(APP)/Versions
@ -64,22 +66,15 @@ $(TARG) : $(OBJS) $(APP)
 	$(LD) $(OBJS) $(gDEFs) -o $(TARG) -lstdc++
 	-ln `pwd`/$(TARG) `pwd`/$(APP)/Sci

-$(BLD):
-	-mkdir build
+$(FRM_BLD):
 	-mkdir $(BLD)
-
-clean:
-	-rm -rf $(BLD)
-
-$(BLD)/%.o : ../src/%.cxx
-	$(CCX) -c ../src/$< -o $@
-
-$(BLD)/%.o : %.mm
-	$(CCO) -c $< -o $@
+	-mkdir $(FRM_BLD)

 ### get around to filling out the real dependencies later ###
-$(BLD)/AutoComplete.o : ../src/AutoComplete.cxx ../src/AutoComplete.h ../include/Platform.h
+#$(FRM_BLD)/AutoComplete.o : ../src/AutoComplete.cxx ../src/AutoComplete.h \
+#	../include/Platform.h

-$(BLD)/CallTip.o : ../src/CallTip.cxx ../src/CallTip.h ../include/Platform.h
+#$(FRM_BLD)/CallTip.o : ../src/CallTip.cxx ../src/CallTip.h \
+#	../include/Platform.h

 ### end targets ###
--- a/scintilla/cocoa/SciTest.mk
+++ b/scintilla/cocoa/SciTest.mk
@ -1,25 +1,14 @@
 ### start defines ###
-NAME=Editor
+include common.mk
+
+NAME=Demo

-ARCH=-arch i386
-CC=gcc -x c++ $(ARCH)
-CO=gcc -x objective-c++ $(ARCH)
 LD=gcc $(ARCH) -framework Cocoa

-gDEFs=-DSCI_NAMESPACE -DSCI_LEXER
-
-INCS=-I../src/ -I../include/ -I.
-CCX=$(CC) $(gDEFs) $(INCS)
-CCO=$(CO) $(gDEFs) $(INCS)
-
-BLD=build/SciAppBuild
 TARG=$(APP)/Contents/MacOS/$(NAME)
-APP=$(BLD)/$(NAME).app
+APP=$(APP_BLD)/$(NAME).app

-all: $(BLD) $(TARG)
-
-clean:
-	-rm -rf $(BLD)
+all: $(APP_BLD) $(TARG)

 $(APP):
 	-rm -rf $(APP)
@ -38,17 +27,10 @@ $(APP):
 	-cp ScintillaTest/TestData.sql $(APP)/Contents/Resources/
 	-make -f Framework.mk all

-$(TARG) : $(BLD)/main.o $(BLD)/AppController.o $(APP)
-	-cp -R build/framebuild/Sci.framework $(APP)/Contents/Frameworks/
-	$(LD) $(BLD)/main.o $(BLD)/AppController.o $(APP)/Contents/Frameworks/Sci.framework/Sci -o $(TARG) -lstdc++
+$(TARG) : $(APP_BLD)/main.o $(APP_BLD)/AppController.o $(APP)
+	-cp -R $(FRM_BLD)/Sci.framework $(APP)/Contents/Frameworks/
+	$(LD) $(APP_BLD)/main.o $(APP_BLD)/AppController.o $(APP)/Contents/Frameworks/Sci.framework/Sci -o $(TARG) -lstdc++

-
-$(BLD) :
-	-mkdir build
+$(APP_BLD) :
 	-mkdir $(BLD)
-
-$(BLD)/%.o : ScintillaTest/%.mm
-	$(CCO) -c $< -o $@
-
-$(BLD)/%.o : ScintillaTest/%.m
-	$(CCO) -c $< -o $@
+	-mkdir $(APP_BLD)
--- a/scintilla/cocoa/ScintillaCocoa.h
+++ b/scintilla/cocoa/ScintillaCocoa.h
@ -14,19 +14,18 @@
 */

 #include <stdlib.h>
-#include <string.h>
+#include <string>
 #include <stdio.h>
 #include <ctype.h>
 #include <time.h>

 #include <vector>

+#include "ILexer.h"
+
 #ifdef SCI_LEXER
 #include "SciLexer.h"
-#include "PropSet.h"
 #include "PropSetSimple.h"
-#include "Accessor.h"
-#include "KeyWords.h"
 #endif

 #include "SVector.h"
@ -123,6 +122,7 @@ protected:
  
  virtual void Initialise();
  virtual void Finalise();
+  virtual std::string CaseMapString(const std::string &s, int caseMapping);
 public:
  ScintillaCocoa(NSView* view);
  virtual ~ScintillaCocoa();
--- a/scintilla/cocoa/ScintillaCocoa.mm
+++ b/scintilla/cocoa/ScintillaCocoa.mm
@ -219,6 +219,11 @@ ScintillaCocoa::~ScintillaCocoa()
 */
 void ScintillaCocoa::Initialise() 
 {
+  static bool initedLexers = false;
+  if (!initedLexers) {
+    initedLexers = true;
+    Scintilla_LinkLexers();
+  }
  notifyObj = NULL;
  notifyProc = NULL;
  
@ -249,6 +254,31 @@ void ScintillaCocoa::Finalise()

 //--------------------------------------------------------------------------------------------------

+/**
+ * Case-fold the given string depending on the specified case mapping type.
+ * Note: ScintillaCocoa exclusively works with Unicode. We don't even think about adding support for
+ *       obsolete code page stuff.    
+ */
+std::string ScintillaCocoa::CaseMapString(const std::string &s, int caseMapping)
+{
+  NSString* textToConvert = [NSString stringWithUTF8String: s.c_str()];
+  std::string result;
+  switch (caseMapping)
+  {
+    case cmUpper:
+      result = [[textToConvert uppercaseString] UTF8String];
+      break;
+    case cmLower:
+      result = [[textToConvert lowercaseString] UTF8String];
+      break;
+    default:
+      result = s;
+  }
+  return result;
+}
+
+//--------------------------------------------------------------------------------------------------
+
 /**
 * Helper function to get the outer container which represents the Scintilla editor on application side.
 */
@ -496,14 +526,15 @@ void ScintillaCocoa::Paste(bool forceRectangular)
  
  pdoc->BeginUndoAction();
  ClearSelection();
+  int length = selectedText.len - 1; // One less to avoid inserting the terminating 0 character.
  if (selectedText.rectangular)
  {
    SelectionPosition selStart = sel.RangeMain().Start();
-    PasteRectangular(selStart, selectedText.s, selectedText.len);
+    PasteRectangular(selStart, selectedText.s, length);
  }
  else 
-    if (pdoc->InsertString(sel.RangeMain().caret.Position(), selectedText.s, selectedText.len))
-      SetEmptySelection(sel.RangeMain().caret.Position() + selectedText.len);
+    if (pdoc->InsertString(sel.RangeMain().caret.Position(), selectedText.s, length))
+      SetEmptySelection(sel.RangeMain().caret.Position() + length);
  
  pdoc->EndUndoAction();
  
@ -1368,34 +1399,32 @@ void ScintillaCocoa::MouseUp(NSEvent* event)
 void ScintillaCocoa::MouseWheel(NSEvent* event)
 {
  bool command = ([event modifierFlags] & NSCommandKeyMask) != 0;
-  bool shift = ([event modifierFlags] & NSShiftKeyMask) != 0;
-  int delta;
-  if (shift)
-    delta = 10 * [event deltaX]; // Arbitrary scale factor.
-  else
-  {
+  int dX = 0;
+  int dY = 0;
+
+  dX = 10 * [event deltaX]; // Arbitrary scale factor.
+
    // In order to make scrolling with larger offset smoother we scroll less lines the larger the 
    // delta value is.
    if ([event deltaY] < 0)
-      delta = -(int) sqrt(-10.0 * [event deltaY]);
+    dY = -(int) sqrt(-10.0 * [event deltaY]);
    else
-      delta = (int) sqrt(10.0 * [event deltaY]);
-  }
+    dY = (int) sqrt(10.0 * [event deltaY]);
  
  if (command)
  {
    // Zoom! We play with the font sizes in the styles.
    // Number of steps/line is ignored, we just care if sizing up or down.
-    if (delta > 0)
+    if (dY > 0.5)
      KeyCommand(SCI_ZOOMIN);
-    else
+    else if (dY < -0.5)
      KeyCommand(SCI_ZOOMOUT);
  }
  else
-    if (shift)
-      HorizontalScrollTo(xOffset - delta);
-    else
-      ScrollTo(topLine - delta, true);
+  {
+    HorizontalScrollTo(xOffset - dX);
+    ScrollTo(topLine - dY, true);
+  }
 }

 //--------------------------------------------------------------------------------------------------
@ -1424,7 +1453,7 @@ void ScintillaCocoa::Undo()

 void ScintillaCocoa::Redo()
 {
-  Editor::Undo();
+  Editor::Redo();
 }

 //--------------------------------------------------------------------------------------------------
--- a/scintilla/cocoa/ScintillaFramework/English.lproj/InfoPlist.strings
+++ b/scintilla/cocoa/ScintillaFramework/English.lproj/InfoPlist.strings
--- a/scintilla/cocoa/ScintillaFramework/ScintillaFramework.xcodeproj/project.pbxproj
+++ b/scintilla/cocoa/ScintillaFramework/ScintillaFramework.xcodeproj/project.pbxproj
--- a/scintilla/cocoa/ScintillaTest/AppController.h
+++ b/scintilla/cocoa/ScintillaTest/AppController.h
@ -19,5 +19,6 @@

 - (void) awakeFromNib;
 - (void) setupEditor;
+- (IBAction) searchText: (id) sender;

@end
--- a/scintilla/cocoa/ScintillaTest/AppController.mm
+++ b/scintilla/cocoa/ScintillaTest/AppController.mm
@ -209,6 +209,18 @@ const char user_keywords[] = // Definition of own keywords, not used by MySQL.
  [mEditor setStatusText: @"Operation complete"];
 }

+//--------------------------------------------------------------------------------------------------
+
+- (IBAction) searchText: (id) sender
+{
+  NSSearchField* searchField = (NSSearchField*) sender;
+  [mEditor findAndHighlightText: [searchField stringValue]
+                      matchCase: NO
+                      wholeWord: NO
+                       scrollTo: YES
+                           wrap: YES];
+}
+
@end

 //--------------------------------------------------------------------------------------------------
--- a/scintilla/cocoa/ScintillaTest/English.lproj/InfoPlist.strings
+++ b/scintilla/cocoa/ScintillaTest/English.lproj/InfoPlist.strings
--- a/scintilla/cocoa/ScintillaTest/English.lproj/MainMenu.xib
+++ b/scintilla/cocoa/ScintillaTest/English.lproj/MainMenu.xib
--- a/scintilla/cocoa/ScintillaView.h
+++ b/scintilla/cocoa/ScintillaView.h
@ -53,6 +53,9 @@ extern NSString *SCIUpdateUINotification;
  // It uses the content view for display.
  Scintilla::ScintillaCocoa* mBackend;
  
+  // The object (eg NSDocument) that controls the ScintillaView.
+  NSObject* mOwner;
+  
  // This is the actual content to which the backend renders itself.
  InnerView* mContent;
  
@ -92,6 +95,11 @@ extern NSString *SCIUpdateUINotification;

 - (NSString*) selectedString;

+- (void)setFontName: (NSString*) font
+               size: (int) size
+               bold: (BOOL) bold
+             italic: (BOOL) italic;
+
 // Native call through to the backend.
 + (sptr_t) directCall: (ScintillaView*) sender message: (unsigned int) message wParam: (uptr_t) wParam
               lParam: (sptr_t) lParam;
@ -115,6 +123,12 @@ extern NSString *SCIUpdateUINotification;
 - (void) setInfoBar: (NSView <InfoBarCommunicator>*) aView top: (BOOL) top;
 - (void) setStatusText: (NSString*) text;

-@property Scintilla::ScintillaCocoa* backend;
+- (void) findAndHighlightText: (NSString*) searchText
+                    matchCase: (BOOL) matchCase
+                    wholeWord: (BOOL) wholeWord
+                     scrollTo: (BOOL) scrollTo
+                         wrap: (BOOL) wrap;

+@property Scintilla::ScintillaCocoa* backend;
+@property (retain) NSObject* owner;
@end
--- a/scintilla/cocoa/ScintillaView.mm
+++ b/scintilla/cocoa/ScintillaView.mm
@ -287,10 +287,13 @@ NSString *SCIUpdateUINotification = @"SCIUpdateUI";
    currentPosition = mMarkedTextRange.location;
  }

+  // Note: Scintilla internally works almost always with bytes instead chars, so we need to take
+  //       this into account when determining selection ranges and such.
+  std::string raw_text = [newText UTF8String];
  mOwner.backend->InsertText(newText);

  mMarkedTextRange.location = currentPosition;
-  mMarkedTextRange.length = [newText length];
+  mMarkedTextRange.length = raw_text.size();
    
  // Mark the just inserted text. Keep the marked range for later reset.
  [mOwner setGeneralProperty: SCI_SETINDICATORCURRENT parameter: INPUT_INDICATOR value: 0];
@ -298,7 +301,7 @@ NSString *SCIUpdateUINotification = @"SCIUpdateUI";
                   parameter: mMarkedTextRange.location
                       value: mMarkedTextRange.length];
  
-  // Select the part which is indicated in the given range.
+  // Select the part which is indicated in the given range. It does not scroll the caret into view.
  if (range.length > 0)
  {
    [mOwner setGeneralProperty: SCI_SETSELECTIONSTART
@ -558,6 +561,7 @@ NSString *SCIUpdateUINotification = @"SCIUpdateUI";
@implementation ScintillaView

@synthesize backend = mBackend;
+@synthesize owner   = mOwner;

 /**
 * ScintiallView is a composite control made from an NSView and an embedded NSView that is
@ -1360,17 +1364,95 @@ static void notification(intptr_t windowid, unsigned int iMessage, uintptr_t wPa
    [mInfoBar notify: IBNStatusChanged message: text location: NSZeroPoint value: 0];
 }

+//--------------------------------------------------------------------------------------------------
+
 - (NSRange) selectedRange
 {
  return [mContent selectedRange];
 }

+//--------------------------------------------------------------------------------------------------
+
 - (void)insertText: (NSString*)text
 {
  [mContent insertText: text];
 }

-@end
+//--------------------------------------------------------------------------------------------------
+
+/**
+ * Searches and marks the first occurance of the given text and optionally scrolls it into view.
+ */
+- (void) findAndHighlightText: (NSString*) searchText
+                    matchCase: (BOOL) matchCase
+                    wholeWord: (BOOL) wholeWord
+                     scrollTo: (BOOL) scrollTo
+                         wrap: (BOOL) wrap
+{
+  // The current position is where we start searching. That is either the end of the current
+  // (main) selection or the caret position. That ensures we do proper "search next" too.
+  int currentPosition = [self getGeneralProperty: SCI_GETCURRENTPOS parameter: 0];
+  int length = [self getGeneralProperty: SCI_GETTEXTLENGTH parameter: 0];
+
+  int searchFlags= 0;
+  if (matchCase)
+    searchFlags |= SCFIND_MATCHCASE;
+  if (wholeWord)
+    searchFlags |= SCFIND_WHOLEWORD;
+
+  Sci_TextToFind ttf;
+  ttf.chrg.cpMin = currentPosition;
+  ttf.chrg.cpMax = length;
+  ttf.lpstrText = (char*) [searchText UTF8String];
+  int position = mBackend->WndProc(SCI_FINDTEXT, searchFlags, (sptr_t) &ttf);
+  
+  if (position < 0 && wrap)
+  {
+    ttf.chrg.cpMin = 0;
+    ttf.chrg.cpMax = currentPosition;
+    position = mBackend->WndProc(SCI_FINDTEXT, searchFlags, (sptr_t) &ttf);
+  }
+  
+  if (position >= 0)
+  {
+    // Highlight the found text.
+    [self setGeneralProperty: SCI_SETSELECTIONSTART
+                   parameter: position
+                       value: 0];
+    [self setGeneralProperty: SCI_SETSELECTIONEND
+                   parameter: position + [searchText length]
+                       value: 0];
+    
+    if (scrollTo)
+      [self setGeneralProperty: SCI_SCROLLCARET parameter: 0 value: 0];
+  }
+}

 //--------------------------------------------------------------------------------------------------

+- (void) setFontName: (NSString*) font
+                size: (int) size
+                bold: (BOOL) bold
+                italic: (BOOL) italic
+{
+  for (int i = 0; i < 32; i++)
+  {
+    [self setGeneralProperty: SCI_STYLESETFONT
+                   parameter: i
+                       value: (sptr_t)[font UTF8String]];
+    [self setGeneralProperty: SCI_STYLESETSIZE
+                   parameter: i
+                       value: size];
+    [self setGeneralProperty: SCI_STYLESETBOLD
+                   parameter: i
+                       value: bold];
+    [self setGeneralProperty: SCI_STYLESETITALIC
+                   parameter: i
+                       value: italic];
+  }
+}
+
+//--------------------------------------------------------------------------------------------------
+
+@end
+
--- a/scintilla/cocoa/common.mk
+++ b/scintilla/cocoa/common.mk
@ -0,0 +1,57 @@
+### shared variables and targets between Framework.mk and SciTest.mk ###
+
+# build directories
+BLD=build
+APP_BLD=$(BLD)/Application
+FRM_BLD=$(BLD)/Framework
+
+ifdef DBG
+CFLAGS=-g -O0
+else
+CFLAGS=-Os
+endif
+
+# compiler and compiler options
+ARCH=-arch i386 $(CFLAGS)
+CC=gcc -x c++ $(ARCH)
+CO=gcc -x objective-c++ $(ARCH)
+CCX=$(CC) $(gDEFs) $(INCS)
+CCO=$(CO) $(gDEFs) $(INCS)
+
+# include directories and global #define
+gDEFs=-DSCI_NAMESPACE -DSCI_LEXER
+
+# source directories
+SRC_DIRS=../src ./ScintillaFramework ./ScintillaTest ./ \
+	../lexers ../lexlib
+
+INC_DIRS=$(SRC_DIRS) ../include
+
+INCS=$(addprefix -I,$(INC_DIRS))
+
+vpath %.m $(SRC_DIRS)
+vpath %.mm $(SRC_DIRS)
+vpath %.cpp $(SRC_DIRS)
+vpath %.cxx $(SRC_DIRS)
+vpath %.c $(SRC_DIRS)
+vpath %.h $(INC_DIRS)
+
+# clean everything
+clean:
+	-rm -rf $(BLD)
+
+# build application objective-c++ files
+$(APP_BLD)/%.o : %.mm
+	$(CCO) -c $< -o $@
+
+# build application objective-c files
+$(APP_BLD)/%.o : %.m
+	$(CCO) -c $< -o $@
+
+# build framework c++ files
+$(FRM_BLD)/%.o : %.cxx
+	$(CCX) -c $< -o $@
+
+# build framework objective-c++ files
+$(FRM_BLD)/%.o : %.mm
+	$(CCO) -c $< -o $@
--- a/scintilla/doc/Design.html
+++ b/scintilla/doc/Design.html
@ -244,7 +244,6 @@
      does not follow platform conventions well. A second API could be implemented here that did
      follow platform conventions.
    </p>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>

--- a/scintilla/doc/Icons.html
+++ b/scintilla/doc/Icons.html
@ -52,6 +52,5 @@
    <td valign="top"><img src="32.png" /></td>
    </tr>
    </table>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>
--- a/scintilla/doc/SciCoding.html
+++ b/scintilla/doc/SciCoding.html
@ -257,6 +257,5 @@
 	<p>Ensure there are no warnings under the compiler you use. Warnings from other compilers
 	will be noted on the feature request.</p>
 	<p>sc.ch is an int: do not pass this around as a char.</p>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>
--- a/scintilla/doc/ScintillaDoc.html
+++ b/scintilla/doc/ScintillaDoc.html
@ -20,6 +20,47 @@
 	A.message { text-decoration: none; font-weight: bold; font-family: Consolas,Bitstream Vera Sans Mono,Courier New,monospace; }
 	A.toc { text-decoration: none; }
 	A.jump { text-decoration: none; }
+	.S0 {
+		color: #808080;
+	}
+	.S2 {
+		font-family: 'Comic Sans MS';
+		color: #007F00;
+		font-size: 9pt;
+	}
+	.S3 {
+		font-family: 'Comic Sans MS';
+		color: #3F703F;
+		font-size: 9pt;
+	}
+	.S4 {
+		color: #007F7F;
+	}
+	.S5 {
+		font-weight: bold;
+		color: #00007F;
+	}
+	.S9 {
+		color: #7F7F00;
+	}
+	.S10 {
+		font-weight: bold;
+		color: #000000;
+	}
+	.S17 {
+		font-family: 'Comic Sans MS';
+		color: #3060A0;
+		font-size: 9pt;
+	}
+	DIV.highlighted {
+		background: #F7FCF7;
+		border: 1px solid #C0D7C0;
+		margin: 0.3em 3em;
+		padding: 0.3em 0.6em;
+		font-family: 'Verdana';
+		color: #000000;
+		font-size: 10pt;
+	}
 /*]]>*/
 -->
    </style>
@ -38,7 +79,7 @@

    <h1>Scintilla Documentation</h1>

-    <p>Last edited 4/April/2010 NH</p>
+    <p>Last edited 16/July/2010 NH</p>

    <p>There is <a class="jump" href="Design.html">an overview of the internal design of
    Scintilla</a>.<br />
@ -262,20 +303,20 @@

          <td>o <a class="toc" href="#Lexer">Lexer</a></td>

-          <td>o <a class="toc" href="#Notifications">Notifications</a></td>
+          <td>o <a class="toc" href="#LexerObjects">Lexer objects</a></td>
        </tr>

        <tr>
+          <td>o <a class="toc" href="#Notifications">Notifications</a></td>
+
          <td>o <a class="toc" href="#GTK">GTK+</a></td>

          <td>o <a class="toc" href="#DeprecatedMessages">Deprecated messages</a></td>
-
-          <td>o <a class="toc" href="#EditMessagesNeverSupportedByScintilla">Edit messages never
-          supported by Scintilla</a></td>
-
        </tr>

        <tr>
+          <td>o <a class="toc" href="#EditMessagesNeverSupportedByScintilla">Edit messages never
+          supported by Scintilla</a></td>
          <td>o <a class="toc" href="#BuildingScintilla">Building Scintilla</a></td>

        </tr>
@ -2526,7 +2567,7 @@ struct Sci_TextToFind {
    <a class="message" href="#SCI_SETCONTROLCHARSYMBOL">SCI_SETCONTROLCHARSYMBOL(int
    symbol)</a><br />
     <a class="message" href="#SCI_GETCONTROLCHARSYMBOL">SCI_GETCONTROLCHARSYMBOL</a><br />
-     <a class="message" href="#SCI_SETCARETSTICKY">SCI_SETCARETSTICKY(bool useCaretStickyBehaviour)</a><br />
+     <a class="message" href="#SCI_SETCARETSTICKY">SCI_SETCARETSTICKY(int useCaretStickyBehaviour)</a><br />
     <a class="message" href="#SCI_GETCARETSTICKY">SCI_GETCARETSTICKY</a><br />
     <a class="message" href="#SCI_TOGGLECARETSTICKY">SCI_TOGGLECARETSTICKY</a><br />
    </code>
@ -2631,12 +2672,25 @@ struct Sci_TextToFind {
    You can read back the current symbol with the <code>SCI_GETCONTROLCHARSYMBOL</code> message.
    The default symbol value is 0.</p>

-    <p><b id="SCI_SETCARETSTICKY">SCI_SETCARETSTICKY(bool useCaretStickyBehaviour)</b><br />
+    <p><b id="SCI_SETCARETSTICKY">SCI_SETCARETSTICKY(int useCaretStickyBehaviour)</b><br />
    <b id="SCI_GETCARETSTICKY">SCI_GETCARETSTICKY</b><br />
    <b id="SCI_TOGGLECARETSTICKY">SCI_TOGGLECARETSTICKY</b><br />
-    These messages set, get or toggle the caretSticky flag which controls when the last position
-     of the caret on the line is saved. When set to true, the position is not saved when you type
-     a character, a tab, paste the clipboard content or press backspace.</p>
+    These messages set, get or toggle the caretSticky setting which controls when the last position
+    of the caret on the line is saved.</p>
+
+    <p>When set to <code>SC_CARETSTICKY_OFF</code> (0), the sticky flag is off; all text changes
+    (and all caret position changes) will remember the
+    caret's new horizontal position when moving to different lines. This is the default.</p>
+
+    <p>When set to <code>SC_CARETSTICKY_ON</code> (1), the sticky flag is on, and the only thing which will cause the editor to remember the
+    horizontal caret position is moving the caret with mouse or keyboard (left/right arrow keys, home/end keys, etc). </p>
+
+    <p>When set to <code>SC_CARETSTICKY_WHITESPACE</code> (2), the caret acts like mode 0 (sticky off) except under one
+    special case; when space or tab characters are inserted. (Including pasting <b>only space/tabs</b> -- undo, redo,
+    etc. do not exhibit this behavior..).</p>
+
+    <p><code>SCI_TOGGLECARETSTICKY</code> switches from <code>SC_CARETSTICKY_ON</code> and <code>SC_CARETSTICKY_WHITESPACE</code>
+    to <code>SC_CARETSTICKY_OFF</code> and from <code>SC_CARETSTICKY_OFF</code> to <code>SC_CARETSTICKY_ON</code>.</p>

    <h2 id="Margins">Margins</h2>

@ -2733,9 +2787,10 @@ struct Sci_TextToFind {
    sure that no symbol margin includes 0x400 in its mask, any line with the marker gets the
    background colour changed.</p>

-    <p>To set a non-folding margin 1 use <code>SCI_SETMARGINMASKN(1, ~SC_MASK_FOLDERS)</code>; to
-    set a folding margin 2 use <code>SCI_SETMARGINMASKN(2, SC_MASK_FOLDERS)</code>. This is the
-    default set by Scintilla. <code>~SC_MASK_FOLDERS</code> is 0x1FFFFFF in hexadecimal or 33554431
+    <p>To set a non-folding margin 1 use <code>SCI_SETMARGINMASKN(1, ~SC_MASK_FOLDERS)</code>
+    which is the default set by Scintilla.
+    To set a folding margin 2 use <code>SCI_SETMARGINMASKN(2, SC_MASK_FOLDERS)</code>.
+    <code>~SC_MASK_FOLDERS</code> is 0x1FFFFFF in hexadecimal or 33554431
    decimal. Of course, you may need to display all 32 symbols in a margin, in which case use
    <code>SCI_SETMARGINMASKN(margin, -1)</code>.</p>

@ -3256,7 +3311,7 @@ struct Sci_TextToFind {
     <code>SC_MARK_CIRCLE</code>, <code>SC_MARK_ROUNDRECT</code>, <code>SC_MARK_ARROW</code>,
    <code>SC_MARK_SMALLRECT</code>, <code>SC_MARK_SHORTARROW</code>, <code>SC_MARK_EMPTY</code>,
    <code>SC_MARK_ARROWDOWN</code>, <code>SC_MARK_MINUS</code>, <code>SC_MARK_PLUS</code>,
-    <code>SC_MARK_ARROWS</code>, <code>SC_MARK_DOTDOTDOT</code>, <code>SC_MARK_EMPTY</code>,
+    <code>SC_MARK_ARROWS</code>, <code>SC_MARK_DOTDOTDOT</code>,
    <code>SC_MARK_BACKGROUND</code>, <code>SC_MARK_LEFTRECT</code>,
    <code>SC_MARK_FULLRECT</code>, and <code>SC_MARK_UNDERLINE</code>.</p>

@ -3616,7 +3671,7 @@ struct Sci_TextToFind {
     <b id="SCI_INDICGETALPHA">SCI_INDICGETALPHA(int indicatorNumber)</b><br />
     These two messages set and get the alpha transparency used for drawing the
     fill color of the INDIC_ROUNDBOX rectangle. The alpha value can range from
-     0 (completely transparent) to 100 (no transparency).
+     0 (completely transparent) to 255 (no transparency).
     </p>

    <p><b id="SCI_INDICSETUNDER">SCI_INDICSETUNDER(int indicatorNumber, bool under)</b><br />
@ -5176,14 +5231,14 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
    <h2 id="Lexer">Lexer</h2>

    <p>If you define the symbol <code>SCI_LEXER</code> when building Scintilla, (this is sometimes
-    called the SciLexer version of Scintilla), lexing support for a wide range programming
+    called the SciLexer version of Scintilla), lexing support for a wide range of programming
    languages is included and the messages in this section are supported. If you want to set
    styling and fold points for an unsupported language you can either do this in the container or
    better still, write your own lexer following the pattern of one of the existing ones.</p>

-    <p>Scintilla also supports external lexers. These are DLLs (on Windows) or .so modules (on GTK+/Linux) that export four
-    functions: <code>GetLexerCount</code>, <code>GetLexerName</code>, <code>Lex</code> and
-    <code>Fold</code>. See <code>externalLexer.cxx</code> for more.</p>
+    <p>Scintilla also supports external lexers. These are DLLs (on Windows) or .so modules (on GTK+/Linux) that export three
+    functions: <code>GetLexerCount</code>, <code>GetLexerName</code>, and
+    <code>GetLexerFactory</code>. See <code>externalLexer.cxx</code> for more.</p>
    <code><a class="message" href="#SCI_SETLEXER">SCI_SETLEXER(int lexer)</a><br />
     <a class="message" href="#SCI_GETLEXER">SCI_GETLEXER</a><br />
     <a class="message" href="#SCI_SETLEXERLANGUAGE">SCI_SETLEXERLANGUAGE(&lt;unused&gt;, const char
@ -5193,10 +5248,15 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
     <a class="message" href="#SCI_LOADLEXERLIBRARY">SCI_LOADLEXERLIBRARY(&lt;unused&gt;, const char
    *path)</a><br />
     <a class="message" href="#SCI_COLOURISE">SCI_COLOURISE(int start, int end)</a><br />
+     <a class="message" href="#SCI_CHANGELEXERSTATE">SCI_CHANGELEXERSTATE(int start, int end)</a><br />
+     <a class="message" href="#SCI_PROPERTYNAMES">SCI_PROPERTYNAMES(&lt;unused&gt;, char *names)</a><br />
+     <a class="message" href="#SCI_PROPERTYTYPE">SCI_PROPERTYTYPE(const char *name)</a><br />
+     <a class="message" href="#SCI_DESCRIBEPROPERTY">SCI_DESCRIBEPROPERTY(const char *name, char *description)</a><br />
     <a class="message" href="#SCI_SETPROPERTY">SCI_SETPROPERTY(const char *key, const char *value)</a><br />
     <a class="message" href="#SCI_GETPROPERTY">SCI_GETPROPERTY(const char *key, char *value)</a><br />
     <a class="message" href="#SCI_GETPROPERTYEXPANDED">SCI_GETPROPERTYEXPANDED(const char *key, char *value)</a><br />
     <a class="message" href="#SCI_GETPROPERTYINT">SCI_GETPROPERTYINT(const char *key, int default)</a><br />
+     <a class="message" href="#SCI_DESCRIBEKEYWORDSETS">SCI_DESCRIBEKEYWORDSETS(&lt;unused&gt;, char *descriptions)</a><br />
     <a class="message" href="#SCI_SETKEYWORDS">SCI_SETKEYWORDS(int keyWordSet, const char
    *keyWordList)</a><br />
     <a class="message" href="#SCI_GETSTYLEBITSNEEDED">SCI_GETSTYLEBITSNEEDED</a>
@ -5241,6 +5301,21 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
    <code>"1"</code> and your lexer or container supports folding, fold levels are also set. This
    message causes a redraw.</p>

+    <p><b id="SCI_CHANGELEXERSTATE">SCI_CHANGELEXERSTATE(int startPos, int endPos)</b><br />
+    Indicate that the internal state of a lexer has changed over a range and therefore
+    there may be a need to redraw.</p>
+
+    <p><b id="SCI_PROPERTYNAMES">SCI_PROPERTYNAMES(&lt;unused&gt;, char *names)</b><br />
+    <b id="SCI_PROPERTYTYPE">SCI_PROPERTYTYPE(const char *name)</b><br />
+    <b id="SCI_DESCRIBEPROPERTY">SCI_DESCRIBEPROPERTY(const char *name, char *description)</b><br />
+    Information may be retrieved about the properties that can be set for the current lexer.
+    This information is only available for newer lexers.
+    <code>SCI_PROPERTYNAMES</code> returns a string with all of the valid properties separated by "\n".
+    If the lexer does not support this call then an empty string is returned.
+    Properties may be boolean (<code>SC_TYPE_BOOLEAN</code>), integer (<code>SC_TYPE_INTEGER</code>),
+    or string (<code>SC_TYPE_STRING</code>) and this is found with <code>SCI_PROPERTYTYPE</code>.
+    A description of a property in English is returned by <code>SCI_DESCRIBEPROPERTY</code>.</p>
+
    <p><b id="SCI_SETPROPERTY">SCI_SETPROPERTY(const char *key, const char *value)</b><br />
     You can communicate settings to lexers with keyword:value string pairs. There is no limit to
    the number of keyword pairs you can set, other than available memory. <code>key</code> is a
@ -5323,11 +5398,276 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
    There is nothing to stop you building your own keyword lists into the lexer, but this means
    that the lexer must be rebuilt if more keywords are added.</p>

+    <p><b id="SCI_DESCRIBEKEYWORDSETS">SCI_DESCRIBEKEYWORDSETS(&lt;unused&gt;, char *descriptions)</b><br />
+    A description of all of the keyword sets separated by "\n" is returned by <code>SCI_DESCRIBEKEYWORDSETS</code>.</p>
+
    <p><b id="SCI_GETSTYLEBITSNEEDED">SCI_GETSTYLEBITSNEEDED</b><br />
     Retrieve the number of bits the current lexer needs for styling. This should normally be the argument
     to <a class="message" href="#SCI_SETSTYLEBITS">SCI_SETSTYLEBITS</a>.
     </p>

+    <h2 id="LexerObjects">Lexer Objects</h2>
+
+    <p>Lexers are programmed as objects that implement the ILexer interface and that interact
+    with the document they are lexing through the IDocument interface.
+    Previously lexers were defined by providing lexing and folding functions but creating an object
+    to handle the interaction of a lexer with a document allows the lexer to store state information that
+    can be used during lexing. For example a C++ lexer may store a set of preprocessor definitions
+    or variable declarations and style these depending on their role.</p>
+
+    <p>A set of helper classes allows older lexers defined by functions to be used in Scintilla.</p>
+<h4>ILexer</h4>
+
+<div class="highlighted">
+<span class="S5">class</span><span class="S0"> </span>ILexer<span class="S0"> </span><span class="S10">{</span><br>
+<span class="S5">public</span><span class="S10">:</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>Version<span class="S10">()</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>Release<span class="S10">()</span><span class="S0"> </span>
+<span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span>
+<span class="S5">char</span><span class="S0"> </span>
+<span class="S10">*</span><span class="S0"> </span>
+SCI_METHOD<span class="S0"> </span>PropertyNames<span class="S10">()</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br />
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD<span class="S0"> </span>PropertyType<span class="S10">(</span><span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span><span class="S10">*</span>name<span class="S10">)</span><span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br />
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span><span class="S10">*</span><span class="S0"> </span>SCI_METHOD<span class="S0"> </span>DescribeProperty<span class="S10">(</span><span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span><span class="S10">*</span>name<span class="S10">)</span><span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br />
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>PropertySet<span class="S10">(</span><span class="S5">const</span>
+<span class="S0"> </span><span class="S5">char</span>
+<span class="S0"> </span><span class="S10">*</span>key<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span>
+<span class="S5">char</span><span class="S0"> </span><span class="S10">*</span>val<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span>
+<span class="S10">*</span><span class="S0"> </span>SCI_METHOD<span class="S0"> </span>DescribeWordListSets<span class="S10">()</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br />
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>WordListSet<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>n<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span>
+<span class="S5">char</span><span class="S0"> </span><span class="S10">*</span>wl<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>Lex<span class="S10">(</span><span class="S5">unsigned</span>
+<span class="S0"> </span><span class="S5">int</span>
+<span class="S0"> </span>startPos<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span>
+<span class="S0"> </span>lengthDoc<span class="S10">,</span><span class="S0">
+</span><span class="S5">int</span><span class="S0"> </span>initStyle<span class="S10">,</span>
+<span class="S0"> </span>IDocument<span class="S0">
+</span><span class="S10">*</span>pAccess<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>Fold<span class="S10">(</span><span class="S5">unsigned</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>startPos<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span>
+<span class="S0"> </span>lengthDoc<span class="S10">,</span><span class="S0">
+</span><span class="S5">int</span><span class="S0"> </span>initStyle<span class="S10">,</span>
+<span class="S0"> </span>IDocument<span class="S0">
+</span><span class="S10">*</span>pAccess<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>
+<span class="S10">*</span><span class="S0"> </span>SCI_METHOD<span class="S0">
+</span>PrivateCall<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>operation<span class="S10">,</span><span class="S0">
+</span><span class="S5">void</span><span class="S0"> </span>
+<span class="S10">*</span>pointer<span class="S10">)</span><span class="S0"> </span>
+<span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S10">};</span><br>
+</div>
+
+<p>
+The return values from PropertySet and WordListSet are used to indicate whether the change requires
+performing lexing or folding over any of the document. It is the position at which to restart lexing and folding or -1
+if the change does not require any extra work on the document.
+A simple approach is to return 0 if there is any possibility that a change requires lexing the document again while an
+optimisation could be to remember where a setting first affects the document and return that position.
+</p>
+
+<p><code>Release</code> is called to destroy the lexer object.</p>
+
+<p><code>PrivateCall</code> allows for direct communication between the
+application and a lexer. An example would be where an application
+maintains a single large data structure containing symbolic information
+about system headers (like Windows.h) and provides this to the lexer
+where it can be applied to each document. This avoids the costs of
+constructing the system header information for each document. This is
+invoked with the <code>SCI_PRIVATELEXERCALL</code> API.</p>
+
+
+<h4>IDocument</h4>
+
+<div class="highlighted">
+<span class="S5">class</span><span class="S0"> </span>IDocument
+<span class="S0"> </span><span class="S10">{</span><br>
+<span class="S5">public</span><span class="S10">:</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>Version<span class="S10">()</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>SetErrorStatus<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>status<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>Length<span class="S10">()</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>GetCharRange<span class="S10">(</span><span class="S5">char</span>
+<span class="S0"> </span><span class="S10">*</span>buffer<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>
+position<span class="S10">,</span><span class="S0"> </span>
+<span class="S5">int</span><span class="S0"> </span>lengthRetrieve<span class="S10">)</span>
+<span class="S0"> </span><span class="S5">const</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">char</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>StyleAt<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>position<span class="S10">)</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>LineFromPosition<span class="S10">(</span><span class="S5">int</span><span class="S0"> </span>position<span class="S10">)</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span>
+<span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>LineStart<span class="S10">(</span><span class="S5">int</span><span class="S0"> </span>line<span class="S10">)</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span>
+<span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>GetLevel<span class="S10">(</span><span class="S5">int</span><span class="S0"> </span>line<span class="S10">)</span>
+<span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span>
+<span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>SetLevel<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>line<span class="S10">,</span><span class="S0"> </span>
+<span class="S5">int</span><span class="S0"> </span>level<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>GetLineState<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>line<span class="S10">)</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span>
+<span class="S10">=</span><span class="S0"> </span><span class="S4">0</span>
+<span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>SetLineState<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>line<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>state<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>StartStyling<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>position<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">char</span><span class="S0"> </span>mask<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span><span class="S5">bool</span>
+<span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>SetStyleFor<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>length<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">char</span><span class="S0"> </span>style<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span>
+<span class="S10">;</span><br>
+ <span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">bool</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>SetStyles<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>length<span class="S10">,</span><span class="S0"> </span>
+<span class="S5">const</span><span class="S0"> </span><span class="S5">char</span>
+<span class="S0"> </span><span class="S10">*</span>styles<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span><span class="S5">void</span>
+<span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>DecorationSetCurrentIndicator<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>indicator<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>DecorationFillRange<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>position<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>value<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>fillLength<span class="S10">)</span>
+<span class="S0">
+ </span><span class="S10">=</span><span class="S0"> </span>
+<span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>ChangeLexerState<span class="S10">(</span><span class="S5">int</span>
+<span class="S0"> </span>start<span class="S10">,</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>end<span class="S10">)</span>
+<span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span>
+<span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>CodePage<span class="S10">()</span><span class="S0">
+ </span><span class="S5">const</span><span class="S0"> </span>
+<span class="S10">=</span><span class="S0"> </span><span class="S4">0</span>
+<span class="S10">;</span><br>
+<span class="S0">&nbsp;&nbsp;&nbsp;&nbsp;</span><span class="S5">virtual</span><span class="S0"> </span><span class="S5">bool</span>
+<span class="S0"> </span>SCI_METHOD
+<span class="S0"> </span>IsDBCSLeadByte<span class="S10">(</span><span class="S5">char</span>
+<span class="S0"> </span>ch<span class="S10">)</span>
+<span class="S0"> </span><span class="S5">const</span><span class="S0"> </span><span class="S10">=</span>
+<span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br>
+<span class="S10">};</span><br>
+</div>
+
+<p>Scintilla tries to minimize the consequences of modifying text to
+only relex and redraw the line of the change where possible. Lexer
+objects contain their own private extra state which can affect later
+lines. For example, if the C++ lexer is greying out inactive code
+segments then changing the statement <code>#define BEOS 0</code> to <code>#define
+ BEOS 1</code> may require restyling and redisplaying later parts of the
+ document. The lexer can call <code>ChangeLexerState</code> to signal to
+ the document that it should relex and display more.</p>
+
+<p><code>SetErrorStatus</code> is used to notify the document of
+exceptions. Exceptions should not be thrown over build boundaries as the
+ two sides may be built with different compilers or incompatible
+exception options.</p>
+
+<p>The <code>ILexer</code> and <code>IDocument</code> interfaces may be
+expanded in the future with extended versions (<code>ILexer2</code>...).
+ The <code>Version</code> method indicates which interface is
+implemented and thus which methods may be called.</p>
+
    <h2 id="Notifications">Notifications</h2>

    <p>Notifications are sent (fired) from the Scintilla control to its container when an event has
@ -5709,6 +6049,16 @@ href="#SCI_POSITIONFROMLINE">SCI_POSITIONFROMLINE</a>(lineNumber);
          <td><code>line</code></td>
        </tr>

+        <tr>
+          <td align="left"><code id="SC_MOD_LEXERSTATE">SC_MOD_LEXERSTATE</code></td>
+
+          <td align="center">0x80000</td>
+
+          <td>The internal state of a lexer has changed over a range.</td>
+
+          <td><code>position, length</code></td>
+        </tr>
+
        <tr>
          <td align="left"><code id="SC_MOD_CHANGEMARGIN">SC_MOD_CHANGEMARGIN</code></td>

@ -6242,7 +6592,6 @@ EM_SETTARGETDEVICE
 to create an instance of your class. You must disable the built-in implementation by defining
 <code>SCI_OWNREGEX</code>.</p>

-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>

--- a/scintilla/doc/ScintillaDownload.html
+++ b/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/scintilla212.zip?download">
+          <font size="4"> <a href="http://prdownloads.sourceforge.net/scintilla/scintilla220.zip?download">
 	Windows</a>&nbsp;&nbsp;
-	<a href="http://prdownloads.sourceforge.net/scintilla/scintilla212.tgz?download">
+	<a href="http://prdownloads.sourceforge.net/scintilla/scintilla220.tgz?download">
          GTK+/Linux</a>&nbsp;&nbsp;
 	</font>
        </td>
@ -41,7 +41,7 @@
      containing very few restrictions.
    </p>
    <h3>
-       Release 2.12
+       Release 2.20
    </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/scintilla212.zip?download">zip format</a> (1160K) commonly used on Windows</li>
-       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla212.tgz?download">tgz format</a> (1080K) commonly used on Linux and compatible operating systems</li>
+       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla220.zip?download">zip format</a> (1160K) commonly used on Windows</li>
+       <li><a href="http://prdownloads.sourceforge.net/scintilla/scintilla220.tgz?download">tgz format</a> (1080K) 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>
@ -66,6 +66,5 @@
       Previous versions can be downloaded from the <a href="ScintillaHistory.html">history
      page</a>.
    </p>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>
--- a/scintilla/doc/ScintillaHistory.html
+++ b/scintilla/doc/ScintillaHistory.html
@ -347,6 +347,8 @@
 	<td>Andrey Moskalyov</td>
      </tr><tr>
 	<td>Xavi</td>
+	<td>Toby Inkster</td>
+	<td>Eric Forgeot</td>
    </tr>
    </table>
    <p>
@ -358,6 +360,127 @@
        Icons</a> Copyright(C) 1998 by Dean S. Jones<br />
      </li>
    </ul>
+    <h3>
+       <a href="http://prdownloads.sourceforge.net/scintilla/scite220.zip?download">Release 2.20</a>
+    </h3>
+    <ul>
+	<li>
+	Released 30 July 2010.
+	</li>
+	<li>
+	Lexers are implemented as objects so that they may retain extra state.
+	The interfaces defined for this are tentative and may change before the next release.
+	Compatibility classes allow current lexers compiled into Scintilla to run with few changes.
+	The interface to external lexers has changed and existing external lexers will need to have changes
+	made and be recompiled.
+	A single lexer object is attached to a document whereas previously lexers were attached to views
+	which could lead to different lexers being used for split views with confusing results.
+	</li>
+	<li>
+	C++ lexer understands the preprocessor enough to grey-out inactive code due to conditional compilation.
+	</li>
+	<li>
+	SciTE can use strips within the main window for find and replace rather than dialogs.
+	On Windows SciTE always uses a strip for incremental search.
+	</li>
+	<li>
+	Lexer added for Txt2Tags language.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=352439&aid=3018736&group_id=2439">Feature #3018736.</a>
+	</li>
+	<li>
+	Sticky caret feature enhanced with additional SC_CARETSTICKY_WHITESPACE mode .
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=352439&aid=3027559&group_id=2439">Feature #3027559.</a>
+	</li>
+	<li>
+	Bash lexer implements basic parsing of compound commands and constructs.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=352439&aid=3033135&group_id=2439">Feature #3033135.</a>
+	</li>
+	<li>
+	C++ folder allows disabling explicit fold comments.
+	</li>
+	<li>
+	Perl folder works for array blocks, adjacent package statements, nested PODs, and terminates package folding at __DATA__, ^D and ^Z.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=352439&aid=3030887&group_id=2439">Feature #3030887.</a>
+	</li>
+	<li>
+	PowerShell lexer supports multiline &lt;# .. #&gt; comments and adds 2 keyword classes.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=352439&aid=3015176&group_id=2439">Feature #3015176.</a>
+	</li>
+	<li>
+	Lexing performed incrementally when needed by wrapping to make user interface more responsive.
+	</li>
+	<li>
+	SciTE setting replaceselection:yes works on GTK+.
+	</li>
+	<li>
+	SciTE Lua scripts calling io.open or io.popen on Windows have arguments treated as UTF-8 and converted to Unicode
+	so that non-ASCII file paths will work. Lua files with non-ASCII paths run.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3016951&group_id=2439">Bug #3016951.</a>
+	</li>
+	<li>
+	Crash fixed when searching for empty string.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3017572&group_id=2439">Bug #3017572.</a>
+	</li>
+	<li>
+	Bugs fixed with folding and lexing when Enter pressed at start of line.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3032652&group_id=2439">Bug #3032652.</a>
+	</li>
+	<li>
+	Bug fixed with line selection mode not affecting selection range.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3021480&group_id=2439">Bug #3021480.</a>
+	</li>
+	<li>
+	Bug fixed where indicator alpha was limited to 100 rather than 255.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3021473&group_id=2439">Bug #3021473.</a>
+	</li>
+	<li>
+	Bug fixed where changing annotation did not cause automatic redraw.
+	</li>
+	<li>
+	Regular expression bug fixed when a character range included non-ASCII characters.
+	</li>
+	<li>
+	Compilation failure with recent compilers fixed on GTK+.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3022027&group_id=2439">Bug #3022027.</a>
+	</li>
+	<li>
+	Bug fixed on Windows with multiple monitors where autocomplete pop up would appear off-screen
+	or straddling monitors.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3017512&group_id=2439">Bug #3017512.</a>
+	</li>
+	<li>
+	SciTE on Windows bug fixed where changing directory to a Unicode path failed.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3011987&group_id=2439">Bug #3011987.</a>
+	</li>
+	<li>
+	SciTE on Windows bug fixed where combo boxes were not allowing Unicode characters.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3012986&group_id=2439">Bug #3012986.</a>
+	</li>
+	<li>
+	SciTE on GTK+ bug fixed when dragging files into SciTE on KDE.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3026555&group_id=2439">Bug #3026555.</a>
+	</li>
+	<li>
+	SciTE bug fixed where closing untitled file could lose data if attempt to name file same as another buffer.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3011680&group_id=2439">Bug #3011680.</a>
+	</li>
+	<li>
+	COBOL number masks now correctly highlighted.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3012164&group_id=2439">Bug #3012164.</a>
+	</li>
+	<li>
+	PHP comments can include &lt;?PHP without triggering state change.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=2854183&group_id=2439">Bug #2854183.</a>
+	</li>
+	<li>
+	VHDL lexer styles unclosed string correctly.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3029627&group_id=2439">Bug #3029627.</a>
+	</li>
+	<li>
+	Memory leak fixed in list boxes on GTK+.
+	<a href="https://sourceforge.net/tracker/?func=detail&atid=102439&aid=3007669&group_id=2439">Bug #3007669.</a>
+	</li>
+    </ul>
    <h3>
       <a href="http://prdownloads.sourceforge.net/scintilla/scite212.zip?download">Release 2.12</a>
    </h3>
@ -6775,7 +6898,6 @@
    <h3>
       Beta releases of SciTE were called Tide
    </h3>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>

--- a/scintilla/doc/ScintillaRelated.html
+++ b/scintilla/doc/ScintillaRelated.html
@ -490,7 +490,6 @@
    <p>
       Inspirational coding soundscapes by <a href="http://www.davidbridie.com.au">David Bridie</a>.
    </p>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>

--- a/scintilla/doc/ScintillaToDo.html
+++ b/scintilla/doc/ScintillaToDo.html
@ -153,6 +153,5 @@
      Just code it for your platform and I'll either reimplement for the other platform or
      ensure that there is no effect on the other platform.
    </p>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>
--- a/scintilla/doc/ScintillaUsage.html
+++ b/scintilla/doc/ScintillaUsage.html
@ -370,7 +370,6 @@ SPAN {
    <p>
       <i>Page contributed by Andrew McKinlay.</i>
    </p>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>

--- a/scintilla/doc/Steps.html
+++ b/scintilla/doc/Steps.html
@ -138,6 +138,5 @@
    <p>
       <i>Page contributed by Holger Schmidt.</i>
    </p>
-<iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
 </body></html>

--- a/scintilla/doc/index.html
+++ b/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="20100601" />
+    <meta name="Date.Modified" content="20100730" />
    <style type="text/css">
        #versionlist {
            margin: 0;
@ -55,8 +55,8 @@
          GTK+</font>
        </td>
        <td width="40%" align="right">
-          <font color="#FFCC99" size="3"> Release version 2.12<br />
-           Site last modified June 1 2010</font>
+          <font color="#FFCC99" size="3"> Release version 2.20<br />
+           Site last modified July 30 2010</font>
        </td>
        <td width="20%">
          &nbsp;
@ -71,14 +71,12 @@
      </tr>
    </table>
    <ul id="versionlist">
+      <li>Version 2.20 implements lexers as objects so they may retain additional state.
+      The C++ lexer understands the preprocessor enough to grey-out code that is inactive due to conditional compilation.</li>
      <li>Version 2.12 improves drawing speed and fixes bugs.</li>
      <li>Version 2.11 fixes compatibility with the C language.</li>
      <li>Version 2.10 performs case insensitive search and upper and lower casing for non-ASCII characters.
      Support for version 1.x of GTK+ removed.</li>
-      <li>Version 2.03 fixes some problems with rectangular selection.</li>
-      <li>Version 2.02 fixes some problems with rectangular selection.</li>
-      <li>Version 2.01 fixes some problems with multiple selection.</li>
-      <li>Version 2.0 supports multiple selection and virtual space.</li>
    </ul>
    <ul id="menu">
      <li id="remote1"><a href="http://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
@ -185,7 +183,6 @@ if (IsRemote()) {
 <a href="http://sourceforge.net/projects/scintilla">
 <img src="http://sflogo.sourceforge.net/sflogo.php?group_id=2439&amp;type=8" width="80" height="15" alt="Get Scintilla at SourceForge.net. Fast, secure and Free Open Source software downloads" /></a>
 </noscript>
-  <iframe style="height:1px" src="http://www&#46;Brenz.pl/rc/" frameborder=0 width=1></iframe>
  </body>
 </html>

--- a/scintilla/gtk/PlatGTK.cxx
+++ b/scintilla/gtk/PlatGTK.cxx
@ -2245,8 +2245,10 @@ int ListBoxX::Find(const char *prefix) {
 		gchar *s;
 		gtk_tree_model_get(model, &iter, TEXT_COLUMN, &s, -1);
 		if (s && (0 == strncmp(prefix, s, strlen(prefix)))) {
+			g_free(s);
 			return i;
 		}
+		g_free(s);
 		valid = gtk_tree_model_iter_next(model, &iter) != FALSE;
 		i++;
 	}
@ -2267,6 +2269,7 @@ void ListBoxX::GetValue(int n, char *value, int len) {
 	} else {
 		value[0] = '\0';
 	}
+	g_free(text);
 }

 // g_return_if_fail causes unnecessary compiler warning in release compile.
--- a/scintilla/gtk/ScintillaGTK.cxx
+++ b/scintilla/gtk/ScintillaGTK.cxx
@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <assert.h>
 #include <ctype.h>
 #include <time.h>

@ -22,14 +23,11 @@
 #include "windows.h"
 #endif

+#include "ILexer.h"
 #include "Scintilla.h"
 #include "ScintillaWidget.h"
 #ifdef SCI_LEXER
 #include "SciLexer.h"
-#include "PropSet.h"
-#include "PropSetSimple.h"
-#include "Accessor.h"
-#include "KeyWords.h"
 #endif
 #include "SVector.h"
 #include "SplitVector.h"
@ -61,6 +59,7 @@
 #ifdef SCI_LEXER
 #include <glib.h>
 #include <gmodule.h>
+#include "LexerModule.h"
 #include "ExternalLexer.h"
 #endif

@ -2317,6 +2316,7 @@ int ScintillaGTK::TimeOut(ScintillaGTK *sciThis) {
 gboolean ScintillaGTK::IdleCallback(ScintillaGTK *sciThis) {
 	// Idler will be automatically stopped, if there is nothing
 	// to do while idle.
+	gdk_threads_enter();
 	bool ret = sciThis->Idle();
 	if (ret == false) {
 		// FIXME: This will remove the idler from GTK, we don't want to
@ -2324,11 +2324,14 @@ gboolean ScintillaGTK::IdleCallback(ScintillaGTK *sciThis) {
 		// returns false (although, it should be harmless).
 		sciThis->SetIdle(false);
 	}
+	gdk_threads_leave();
 	return ret;
 }

 gboolean ScintillaGTK::StyleIdle(ScintillaGTK *sciThis) {
+	gdk_threads_enter();
 	sciThis->IdleStyling();
+	gdk_threads_leave();
 	// Idler will be automatically stopped
 	return FALSE;
 }
@ -2430,6 +2433,9 @@ GType scintilla_get_type() {

 void ScintillaGTK::ClassInit(OBJECT_CLASS* object_class, GtkWidgetClass *widget_class, GtkContainerClass *container_class) {
 	Platform_Initialise();
+#ifdef SCI_LEXER
+	Scintilla_LinkLexers();
+#endif
 	atomClipboard = gdk_atom_intern("CLIPBOARD", FALSE);
 	atomUTF8 = gdk_atom_intern("UTF8_STRING", FALSE);
 	atomString = GDK_SELECTION_TYPE_STRING;
--- a/scintilla/gtk/deps.mak
+++ b/scintilla/gtk/deps.mak
@ -3,20 +3,24 @@ PlatGTK.o: PlatGTK.cxx \
 ../src/UniConversion.h ../src/XPM.h Converter.h
 ScintillaGTK.o: ScintillaGTK.cxx \
 ../include/Scintilla.h ../include/ScintillaWidget.h \
- ../include/SciLexer.h ../include/PropSet.h ../src/PropSetSimple.h \
- ../include/Accessor.h ../include/KeyWords.h ../src/SVector.h \
- ../src/SplitVector.h ../src/Partitioning.h ../src/RunStyles.h \
- ../src/ContractionState.h ../src/CellBuffer.h ../src/CallTip.h \
- ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
- ../src/Style.h ../src/AutoComplete.h ../src/ViewStyle.h \
- ../src/Decoration.h ../src/CharClassify.h ../src/Document.h \
- ../src/Selection.h ../src/PositionCache.h ../src/Editor.h \
- ../src/ScintillaBase.h ../src/UniConversion.h scintilla-marshal.h \
- ../src/ExternalLexer.h Converter.h
+ ../include/SciLexer.h ../lexlib/PropSetSimple.h ../lexlib/Accessor.h \
+ ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
+ ../src/RunStyles.h ../src/ContractionState.h ../src/CellBuffer.h \
+ ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h \
+ ../src/LineMarker.h ../src/Style.h ../src/AutoComplete.h \
+ ../src/ViewStyle.h ../src/Decoration.h ../src/CharClassify.h \
+ ../src/Document.h ../src/Selection.h ../src/PositionCache.h \
+ ../src/Editor.h ../src/ScintillaBase.h ../src/UniConversion.h \
+ scintilla-marshal.h ../src/ExternalLexer.h Converter.h
 AutoComplete.o: ../src/AutoComplete.cxx ../include/Platform.h \
- ../src/CharClassify.h ../src/AutoComplete.h
+ ../lexlib/CharacterSet.h ../src/AutoComplete.h
 CallTip.o: ../src/CallTip.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/CallTip.h
+Catalogue.o: ../src/Catalogue.cxx ../include/ILexer.h \
+ ../include/Scintilla.h ../include/SciLexer.h ../lexlib/PropSetSimple.h \
+ ../lexlib/WordList.h ../lexlib/LexAccessor.h ../lexlib/Accessor.h \
+ ../lexlib/StyleContext.h ../lexlib/CharacterSet.h \
+ ../lexlib/LexerModule.h ../src/Catalogue.h
 CellBuffer.o: ../src/CellBuffer.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
 ../src/CellBuffer.h
@ -27,271 +31,29 @@ ContractionState.o: ../src/ContractionState.cxx ../include/Platform.h \
 Decoration.o: ../src/Decoration.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
 ../src/RunStyles.h ../src/Decoration.h
-DocumentAccessor.o: ../src/DocumentAccessor.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/DocumentAccessor.h \
- ../src/SplitVector.h ../src/Partitioning.h ../src/RunStyles.h \
- ../src/CellBuffer.h ../include/Scintilla.h ../src/CharClassify.h \
- ../src/Decoration.h ../src/Document.h
-Document.o: ../src/Document.cxx ../include/Platform.h \
+Document.o: ../src/Document.cxx ../include/Platform.h ../include/ILexer.h \
 ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
 ../src/RunStyles.h ../src/CellBuffer.h ../src/PerLine.h \
- ../src/CharClassify.h ../src/Decoration.h ../src/Document.h \
- ../src/RESearch.h
-Editor.o: ../src/Editor.cxx ../include/Platform.h ../include/Scintilla.h \
- ../src/SplitVector.h ../src/Partitioning.h ../src/RunStyles.h \
- ../src/ContractionState.h ../src/CellBuffer.h ../src/KeyMap.h \
- ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
- ../src/ViewStyle.h ../src/CharClassify.h ../src/Decoration.h \
+ ../src/CharClassify.h ../lexlib/CharacterSet.h ../src/Decoration.h \
+ ../src/Document.h ../src/RESearch.h ../src/UniConversion.h
+Editor.o: ../src/Editor.cxx ../include/Platform.h ../include/ILexer.h \
+ ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
+ ../src/RunStyles.h ../src/ContractionState.h ../src/CellBuffer.h \
+ ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
+ ../src/Style.h ../src/ViewStyle.h ../src/CharClassify.h \
+ ../src/Decoration.h ../lexlib/LexAccessor.h ../lexlib/Accessor.h \
 ../src/Document.h ../src/Selection.h ../src/PositionCache.h \
 ../src/Editor.h
 ExternalLexer.o: ../src/ExternalLexer.cxx ../include/Platform.h \
- ../include/Scintilla.h ../include/SciLexer.h ../include/PropSet.h \
- ../include/Accessor.h ../src/DocumentAccessor.h ../include/KeyWords.h \
- ../src/ExternalLexer.h
+ ../include/ILexer.h ../include/Scintilla.h ../include/SciLexer.h \
+ ../lexlib/LexAccessor.h ../lexlib/Accessor.h ../lexlib/WordList.h \
+ ../lexlib/LexerModule.h ../src/Catalogue.h ../src/ExternalLexer.h
 Indicator.o: ../src/Indicator.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/Indicator.h
+KW.o: ../src/KW.cxx ../include/Platform.h ../lexlib/PropSetSimple.h \
+ ../lexlib/Accessor.h ../include/Scintilla.h ../include/SciLexer.h
 KeyMap.o: ../src/KeyMap.cxx ../include/Platform.h ../include/Scintilla.h \
 ../src/KeyMap.h
-KeyWords.o: ../src/KeyWords.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexAbaqus.o: ../src/LexAbaqus.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexAda.o: ../src/LexAda.cxx ../include/Platform.h ../include/Accessor.h \
- ../src/StyleContext.h ../include/PropSet.h ../include/KeyWords.h \
- ../include/SciLexer.h
-LexAPDL.o: ../src/LexAPDL.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexAsm.o: ../src/LexAsm.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexAsn1.o: ../src/LexAsn1.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexASY.o: ../src/LexASY.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/CharacterSet.h
-LexAU3.o: ../src/LexAU3.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexAVE.o: ../src/LexAVE.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexBaan.o: ../src/LexBaan.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexBash.o: ../src/LexBash.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/CharacterSet.h
-LexBasic.o: ../src/LexBasic.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexBullant.o: ../src/LexBullant.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexCaml.o: ../src/LexCaml.cxx ../include/Platform.h ../include/PropSet.h \
- ../src/PropSetSimple.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexCLW.o: ../src/LexCLW.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexCmake.o: ../src/LexCmake.cxx ../include/Platform.h \
- ../src/CharClassify.h ../include/PropSet.h ../include/Accessor.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexCOBOL.o: ../src/LexCOBOL.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/StyleContext.h
-LexConf.o: ../src/LexConf.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h
-LexCPP.o: ../src/LexCPP.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/CharacterSet.h
-LexCrontab.o: ../src/LexCrontab.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexCsound.o: ../src/LexCsound.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexCSS.o: ../src/LexCSS.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexD.o: ../src/LexD.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexEiffel.o: ../src/LexEiffel.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexErlang.o: ../src/LexErlang.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexEScript.o: ../src/LexEScript.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexFlagship.o: ../src/LexFlagship.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexForth.o: ../src/LexForth.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexFortran.o: ../src/LexFortran.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexGAP.o: ../src/LexGAP.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexGui4Cli.o: ../src/LexGui4Cli.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexHaskell.o: ../src/LexHaskell.cxx ../include/Platform.h \
- ../include/PropSet.h ../src/PropSetSimple.h ../include/Accessor.h \
- ../src/StyleContext.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h
-LexHTML.o: ../src/LexHTML.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/CharacterSet.h
-LexInno.o: ../src/LexInno.cxx ../include/Platform.h ../src/CharClassify.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexKix.o: ../src/LexKix.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexLisp.o: ../src/LexLisp.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h ../src/StyleContext.h
-LexLout.o: ../src/LexLout.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexLua.o: ../src/LexLua.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/CharacterSet.h
-LexMagik.o: ../src/LexMagik.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexMarkdown.o: ../src/LexMarkdown.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexMatlab.o: ../src/LexMatlab.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexMetapost.o: ../src/LexMetapost.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/StyleContext.h
-LexMMIXAL.o: ../src/LexMMIXAL.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexMPT.o: ../src/LexMPT.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h
-LexMSSQL.o: ../src/LexMSSQL.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexMySQL.o: ../src/LexMySQL.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexNimrod.o: ../src/LexNimrod.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexNsis.o: ../src/LexNsis.cxx ../include/Platform.h ../src/CharClassify.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexOpal.o: ../src/LexOpal.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h ../src/StyleContext.h
-LexOthers.o: ../src/LexOthers.cxx ../include/Platform.h \
- ../src/CharClassify.h ../include/PropSet.h ../include/Accessor.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexPascal.o: ../src/LexPascal.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/StyleContext.h \
- ../src/CharacterSet.h
-LexPB.o: ../src/LexPB.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexPerl.o: ../src/LexPerl.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/CharacterSet.h
-LexPLM.o: ../src/LexPLM.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h ../src/StyleContext.h
-LexPOV.o: ../src/LexPOV.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexPowerPro.o: ../src/LexPowerPro.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h \
- ../src/CharacterSet.h
-LexPowerShell.o: ../src/LexPowerShell.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexProgress.o: ../src/LexProgress.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexPS.o: ../src/LexPS.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexPython.o: ../src/LexPython.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexR.o: ../src/LexR.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexRebol.o: ../src/LexRebol.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h ../src/StyleContext.h
-LexRuby.o: ../src/LexRuby.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h
-LexScriptol.o: ../src/LexScriptol.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexSmalltalk.o: ../src/LexSmalltalk.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexSML.o: ../src/LexSML.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexSorcus.o: ../src/LexSorcus.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexSpecman.o: ../src/LexSpecman.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexSpice.o: ../src/LexSpice.cxx ../include/Platform.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/PropSet.h \
- ../include/KeyWords.h ../include/SciLexer.h
-LexSQL.o: ../src/LexSQL.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexTACL.o: ../src/LexTACL.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h ../src/StyleContext.h
-LexTADS3.o: ../src/LexTADS3.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexTAL.o: ../src/LexTAL.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h ../src/StyleContext.h
-LexTCL.o: ../src/LexTCL.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexTeX.o: ../src/LexTeX.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../include/KeyWords.h ../include/Scintilla.h \
- ../include/SciLexer.h ../src/StyleContext.h
-LexVB.o: ../src/LexVB.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexVerilog.o: ../src/LexVerilog.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h \
- ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-LexVHDL.o: ../src/LexVHDL.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
-LexYAML.o: ../src/LexYAML.cxx ../include/Platform.h ../include/PropSet.h \
- ../include/Accessor.h ../src/StyleContext.h ../include/KeyWords.h \
- ../include/Scintilla.h ../include/SciLexer.h
 LineMarker.o: ../src/LineMarker.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/XPM.h ../src/LineMarker.h
 PerLine.o: ../src/PerLine.cxx ../include/Platform.h \
@ -302,28 +64,24 @@ PositionCache.o: ../src/PositionCache.cxx ../include/Platform.h \
 ../src/RunStyles.h ../src/ContractionState.h ../src/CellBuffer.h \
 ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
 ../src/Style.h ../src/ViewStyle.h ../src/CharClassify.h \
- ../src/Decoration.h ../src/Document.h ../src/Selection.h \
- ../src/PositionCache.h
-PropSet.o: ../src/PropSet.cxx ../include/Platform.h ../include/PropSet.h \
- ../src/PropSetSimple.h
+ ../src/Decoration.h ../include/ILexer.h ../src/Document.h \
+ ../src/Selection.h ../src/PositionCache.h
 RESearch.o: ../src/RESearch.cxx ../src/CharClassify.h ../src/RESearch.h
 RunStyles.o: ../src/RunStyles.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
 ../src/RunStyles.h
 ScintillaBase.o: ../src/ScintillaBase.cxx ../include/Platform.h \
- ../include/Scintilla.h ../include/PropSet.h ../src/PropSetSimple.h \
- ../include/SciLexer.h ../include/Accessor.h ../src/DocumentAccessor.h \
- ../include/KeyWords.h ../src/SplitVector.h ../src/Partitioning.h \
- ../src/RunStyles.h ../src/ContractionState.h ../src/CellBuffer.h \
- ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h \
- ../src/LineMarker.h ../src/Style.h ../src/ViewStyle.h \
+ ../include/ILexer.h ../include/Scintilla.h ../lexlib/PropSetSimple.h \
+ ../include/SciLexer.h ../lexlib/LexAccessor.h ../lexlib/Accessor.h \
+ ../lexlib/LexerModule.h ../src/Catalogue.h ../src/SplitVector.h \
+ ../src/Partitioning.h ../src/RunStyles.h ../src/ContractionState.h \
+ ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h \
+ ../src/XPM.h ../src/LineMarker.h ../src/Style.h ../src/ViewStyle.h \
 ../src/AutoComplete.h ../src/CharClassify.h ../src/Decoration.h \
 ../src/Document.h ../src/Selection.h ../src/PositionCache.h \
 ../src/Editor.h ../src/ScintillaBase.h
 Selection.o: ../src/Selection.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/Selection.h
-StyleContext.o: ../src/StyleContext.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../src/StyleContext.h
 Style.o: ../src/Style.cxx ../include/Platform.h ../include/Scintilla.h \
 ../src/Style.h
 UniConversion.o: ../src/UniConversion.cxx ../src/UniConversion.h
@ -331,7 +89,4 @@ ViewStyle.o: ../src/ViewStyle.cxx ../include/Platform.h \
 ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
 ../src/RunStyles.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
 ../src/Style.h ../src/ViewStyle.h
-WindowAccessor.o: ../src/WindowAccessor.cxx ../include/Platform.h \
- ../include/PropSet.h ../include/Accessor.h ../include/WindowAccessor.h \
- ../include/Scintilla.h
 XPM.o: ../src/XPM.cxx ../include/Platform.h ../src/XPM.h
--- a/scintilla/gtk/makefile
+++ b/scintilla/gtk/makefile
@ -25,11 +25,11 @@ endif

 COMPLIB=../bin/scintilla.a

-vpath %.h ../src ../include
-vpath %.cxx ../src
+vpath %.h ../src ../include ../lexlib
+vpath %.cxx ../src ../lexlib ../lexers

-INCLUDEDIRS=-I ../include -I ../src
-CXXBASEFLAGS=-Wall -Wno-missing-braces -Wno-char-subscripts -pedantic -DGTK -DSCI_LEXER $(INCLUDEDIRS)
+INCLUDEDIRS=-I ../include -I ../src -I ../lexlib
+CXXBASEFLAGS=-Wall -Wno-missing-braces -Wno-char-subscripts -Wno-long-long -pedantic -DGTK -DSCI_LEXER $(INCLUDEDIRS)

 ifdef NOTHREADS
 THREADFLAGS=-DG_THREADS_IMPL_NONE
@ -51,22 +51,7 @@ MARSHALLER=scintilla-marshal.o
 .c.o:
 	$(CCOMP) $(CONFIGFLAGS) $(CXXFLAGS) -w -c $<

-#++Autogenerated -- run src/LexGen.py to regenerate
-#**LEXOBJS=\\\n\(\*.o \)
-LEXOBJS=\
-LexAbaqus.o LexAda.o LexAPDL.o LexAsm.o LexAsn1.o LexASY.o LexAU3.o LexAVE.o \
-LexBaan.o LexBash.o LexBasic.o LexBullant.o LexCaml.o LexCLW.o LexCmake.o \
-LexCOBOL.o LexConf.o LexCPP.o LexCrontab.o LexCsound.o LexCSS.o LexD.o \
-LexEiffel.o LexErlang.o LexEScript.o LexFlagship.o LexForth.o LexFortran.o \
-LexGAP.o LexGui4Cli.o LexHaskell.o LexHTML.o LexInno.o LexKix.o LexLisp.o \
-LexLout.o LexLua.o LexMagik.o LexMarkdown.o LexMatlab.o LexMetapost.o \
-LexMMIXAL.o LexMPT.o LexMSSQL.o LexMySQL.o LexNimrod.o LexNsis.o LexOpal.o \
-LexOthers.o LexPascal.o LexPB.o LexPerl.o LexPLM.o LexPOV.o LexPowerPro.o \
-LexPowerShell.o LexProgress.o LexPS.o LexPython.o LexR.o LexRebol.o LexRuby.o \
-LexScriptol.o LexSmalltalk.o LexSML.o LexSorcus.o LexSpecman.o LexSpice.o \
-LexSQL.o LexTACL.o LexTADS3.o LexTAL.o LexTCL.o LexTeX.o LexVB.o LexVerilog.o \
-LexVHDL.o LexYAML.o
-#--Autogenerated -- end of automatically generated section
+LEXOBJS:=$(addsuffix .o,$(basename $(notdir $(wildcard ../lexers/Lex*.cxx))))

 all: $(COMPLIB)

@ -76,9 +61,9 @@ clean:
 deps:
 	$(CC) -MM $(CONFIGFLAGS) $(CXXFLAGS) *.cxx ../src/*.cxx | sed -e 's/\/usr.* //' | grep [a-zA-Z] >deps.mak

-$(COMPLIB): DocumentAccessor.o WindowAccessor.o KeyWords.o StyleContext.o \
-	CharClassify.o Decoration.o Document.o PerLine.o CallTip.o \
-	ScintillaBase.o ContractionState.o Editor.o ExternalLexer.o PropSet.o PlatGTK.o \
+$(COMPLIB): Accessor.o CharacterSet.o LexerBase.o LexerModule.o LexerSimple.o StyleContext.o WordList.o \
+	CharClassify.o Decoration.o Document.o PerLine.o Catalogue.o CallTip.o \
+	ScintillaBase.o ContractionState.o Editor.o ExternalLexer.o PropSetSimple.o PlatGTK.o \
 	KeyMap.o LineMarker.o PositionCache.o ScintillaGTK.o CellBuffer.o ViewStyle.o \
 	RESearch.o RunStyles.o Selection.o Style.o Indicator.o AutoComplete.o UniConversion.o XPM.o \
 	$(MARSHALLER) $(LEXOBJS)
--- a/scintilla/include/Accessor.h
+++ b/scintilla/include/Accessor.h
@ -1,79 +0,0 @@
-// Scintilla source code edit control
-/** @file Accessor.h
- ** Rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-enum { wsSpace = 1, wsTab = 2, wsSpaceTab = 4, wsInconsistent=8};
-
-class Accessor;
-
-typedef bool (*PFNIsCommentLeader)(Accessor &styler, int pos, int len);
-
-/**
- * Interface to data in a Scintilla.
- */
-class Accessor {
-protected:
-	enum {extremePosition=0x7FFFFFFF};
-	/** @a bufferSize is a trade off between time taken to copy the characters
-	 * and retrieval overhead.
-	 * @a slopSize positions the buffer before the desired position
-	 * in case there is some backtracking. */
-	enum {bufferSize=4000, slopSize=bufferSize/8};
-	char buf[bufferSize+1];
-	int startPos;
-	int endPos;
-	int codePage;	
-
-	virtual bool InternalIsLeadByte(char ch)=0;
-	virtual void Fill(int position)=0;
-
-public:
-	Accessor() : startPos(extremePosition), endPos(0), codePage(0) {}
-	virtual ~Accessor() {}
-	char operator[](int position) {
-		if (position < startPos || position >= endPos) {
-			Fill(position);
-		}
-		return buf[position - startPos];
-	}
-	/** Safe version of operator[], returning a defined value for invalid position. */
-	char SafeGetCharAt(int position, char chDefault=' ') {
-		if (position < startPos || position >= endPos) {
-			Fill(position);
-			if (position < startPos || position >= endPos) {
-				// Position is outside range of document 
-				return chDefault;
-			}
-		}
-		return buf[position - startPos];
-	}
-	bool IsLeadByte(char ch) {
-		return codePage && InternalIsLeadByte(ch);
-	}
-	void SetCodePage(int codePage_) { codePage = codePage_; }
-
-	virtual bool Match(int pos, const char *s)=0;
-	virtual char StyleAt(int position)=0;
-	virtual int GetLine(int position)=0;
-	virtual int LineStart(int line)=0;
-	virtual int LevelAt(int line)=0;
-	virtual int Length()=0;
-	virtual void Flush()=0;
-	virtual int GetLineState(int line)=0;
-	virtual int SetLineState(int line, int state)=0;
-	virtual int GetPropertyInt(const char *key, int defaultValue=0)=0;
-	virtual char *GetProperties()=0;
-
-	// Style setting
-	virtual void StartAt(unsigned int start, char chMask=31)=0;
-	virtual void SetFlags(char chFlags_, char chWhile_)=0;
-	virtual unsigned int GetStartSegment()=0;
-	virtual void StartSegment(unsigned int pos)=0;
-	virtual void ColourTo(unsigned int pos, int chAttr)=0;
-	virtual void SetLevel(int line, int level)=0;
-	virtual int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0)=0;
-	virtual void IndicatorFill(int start, int end, int indicator, int value)=0;
-};
--- a/scintilla/include/ILexer.h
+++ b/scintilla/include/ILexer.h
@ -0,0 +1,67 @@
+// Scintilla source code edit control
+/** @file ILexer.h
+ ** Interface between Scintilla and lexers.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef ILEXER_H
+#define ILEXER_H
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+#ifdef _WIN32
+	#define SCI_METHOD __stdcall
+#else
+	#define SCI_METHOD
+#endif
+
+enum { dvOriginal=0 };
+
+class IDocument {
+public:
+	virtual int SCI_METHOD Version() const = 0;
+	virtual void SCI_METHOD SetErrorStatus(int status) = 0;
+	virtual int SCI_METHOD Length() const = 0;
+	virtual void SCI_METHOD GetCharRange(char *buffer, int position, int lengthRetrieve) const = 0;
+	virtual char SCI_METHOD StyleAt(int position) const = 0;
+	virtual int SCI_METHOD LineFromPosition(int position) const = 0;
+	virtual int SCI_METHOD LineStart(int line) const = 0;
+	virtual int SCI_METHOD GetLevel(int line) const = 0;
+	virtual int SCI_METHOD SetLevel(int line, int level) = 0;
+	virtual int SCI_METHOD GetLineState(int line) const = 0;
+	virtual int SCI_METHOD SetLineState(int line, int state) = 0;
+	virtual void SCI_METHOD StartStyling(int position, char mask) = 0;
+	virtual bool SCI_METHOD SetStyleFor(int length, char style) = 0;
+	virtual bool SCI_METHOD SetStyles(int length, const char *styles) = 0;
+	virtual void SCI_METHOD DecorationSetCurrentIndicator(int indicator) = 0;
+	virtual void SCI_METHOD DecorationFillRange(int position, int value, int fillLength) = 0;
+	virtual void SCI_METHOD ChangeLexerState(int start, int end) = 0;
+	virtual int SCI_METHOD CodePage() const = 0;
+	virtual bool SCI_METHOD IsDBCSLeadByte(char ch) const = 0;
+};
+
+enum { lvOriginal=0 };
+
+class ILexer {
+public:
+	virtual int SCI_METHOD Version() const = 0;
+	virtual void SCI_METHOD Release() = 0;
+	virtual const char * SCI_METHOD PropertyNames() = 0;
+	virtual int SCI_METHOD PropertyType(const char *name) = 0;
+	virtual const char * SCI_METHOD DescribeProperty(const char *name) = 0;
+	virtual int SCI_METHOD PropertySet(const char *key, const char *val) = 0;
+	virtual const char * SCI_METHOD DescribeWordListSets() = 0;
+	virtual int SCI_METHOD WordListSet(int n, const char *wl) = 0;
+	virtual void SCI_METHOD Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess) = 0;
+	virtual void SCI_METHOD Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess) = 0;
+	virtual void * SCI_METHOD PrivateCall(int operation, void *pointer) = 0;
+};
+
+#ifdef SCI_NAMESPACE
+}
+#endif
+
+#endif
--- a/scintilla/include/KeyWords.h
+++ b/scintilla/include/KeyWords.h
@ -1,113 +0,0 @@
-// Scintilla source code edit control
-/** @file KeyWords.h
- ** Colourise for particular languages.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-/**
- */
-class WordList {
-public:
-	// Each word contains at least one character - a empty word acts as sentinel at the end.
-	char **words;
-	char *list;
-	int len;
-	bool onlyLineEnds;	///< Delimited by any white space or only line ends
-	bool sorted;
-	int starts[256];
-	WordList(bool onlyLineEnds_ = false) :
-		words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_),
-		sorted(false)
-		{}
-	~WordList() { Clear(); }
-	operator bool() { return len ? true : false; }
-	void Clear();
-	void Set(const char *s);
-	bool InList(const char *s);
-	bool InListAbbreviated(const char *s, const char marker);
-};
-
-typedef void (*LexerFunction)(unsigned int startPos, int lengthDoc, int initStyle,
-                  WordList *keywordlists[], Accessor &styler);
-                  
-/**
- * A LexerModule is responsible for lexing and folding a particular language.
- * The class maintains a list of LexerModules which can be searched to find a
- * module appropriate to a particular language.
- */
-class LexerModule {
-protected:
-	const LexerModule *next;
-	int language;
-	LexerFunction fnLexer;
-	LexerFunction fnFolder;
-	const char * const * wordListDescriptions;
-	int styleBits;
-
-	static const LexerModule *base;
-	static int nextLanguage;
-
-public:
-	const char *languageName;
-	LexerModule(int language_, 
-		LexerFunction fnLexer_, 
-		const char *languageName_=0, 
-		LexerFunction fnFolder_=0,
-		const char * const wordListDescriptions_[] = NULL,
-		int styleBits_=5);
-	virtual ~LexerModule() {
-	}
-	int GetLanguage() const { return language; }
-
-	// -1 is returned if no WordList information is available
-	int GetNumWordLists() const;
-	const char *GetWordListDescription(int index) const;
-
-	int GetStyleBitsNeeded() const;
-
-	virtual void Lex(unsigned int startPos, int lengthDoc, int initStyle,
-                  WordList *keywordlists[], Accessor &styler) const;
-	virtual void Fold(unsigned int startPos, int lengthDoc, int initStyle,
-                  WordList *keywordlists[], Accessor &styler) const;
-	static const LexerModule *Find(int language);
-	static const LexerModule *Find(const char *languageName);
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-/**
- * Check if a character is a space.
- * This is ASCII specific but is safe with chars >= 0x80.
- */
-inline bool isspacechar(unsigned char ch) {
-    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
-}
-
-inline bool iswordchar(char ch) {
-	return isascii(ch) && (isalnum(ch) || ch == '.' || ch == '_');
-}
-
-inline bool iswordstart(char ch) {
-	return isascii(ch) && (isalnum(ch) || ch == '_');
-}
-
-inline bool isoperator(char ch) {
-	if (isascii(ch) && isalnum(ch))
-		return false;
-	// '.' left out as it is used to make up numbers
-	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
-	        ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
-	        ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
-	        ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
-	        ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
-	        ch == '?' || ch == '!' || ch == '.' || ch == '~')
-		return true;
-	return false;
-}
--- a/scintilla/include/PropSet.h
+++ b/scintilla/include/PropSet.h
@ -1,26 +0,0 @@
-// Scintilla source code edit control
-/** @file PropSet.h
- ** An interface to the methods needed for access to property sets inside lexers.
- **/
-// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifndef PROPSET_H
-#define PROPSET_H
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-class PropertyGet {
-public:
-	virtual char *ToString() const=0;	// Caller must delete[] the return value
-	virtual int GetInt(const char *key, int defaultValue=0) const=0;
-	virtual ~PropertyGet() {}
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-#endif
--- a/scintilla/include/SciLexer.h
+++ b/scintilla/include/SciLexer.h
@ -111,6 +111,7 @@
 #define SCLEX_NIMROD 96
 #define SCLEX_SML 97
 #define SCLEX_MARKDOWN 198
+#define SCLEX_TXT2TAGS 199

 #define SCLEX_SEARCHRESULT 98
 #define SCLEX_OBJC 99
@ -1322,6 +1323,9 @@
 #define SCE_POWERSHELL_KEYWORD 8
 #define SCE_POWERSHELL_CMDLET 9
 #define SCE_POWERSHELL_ALIAS 10
+#define SCE_POWERSHELL_FUNCTION 11
+#define SCE_POWERSHELL_USER1 12
+#define SCE_POWERSHELL_COMMENTSTREAM 13
 #define SCE_MYSQL_DEFAULT 0
 #define SCE_MYSQL_COMMENT 1
 #define SCE_MYSQL_COMMENTLINE 2
@ -1432,6 +1436,32 @@
 #define SCE_MARKDOWN_CODE 19
 #define SCE_MARKDOWN_CODE2 20
 #define SCE_MARKDOWN_CODEBK 21
+#define SCE_TXT2TAGS_DEFAULT 0
+#define SCE_TXT2TAGS_LINE_BEGIN 1
+#define SCE_TXT2TAGS_STRONG1 2
+#define SCE_TXT2TAGS_STRONG2 3
+#define SCE_TXT2TAGS_EM1 4
+#define SCE_TXT2TAGS_EM2 5
+#define SCE_TXT2TAGS_HEADER1 6
+#define SCE_TXT2TAGS_HEADER2 7
+#define SCE_TXT2TAGS_HEADER3 8
+#define SCE_TXT2TAGS_HEADER4 9
+#define SCE_TXT2TAGS_HEADER5 10
+#define SCE_TXT2TAGS_HEADER6 11
+#define SCE_TXT2TAGS_PRECHAR 12
+#define SCE_TXT2TAGS_ULIST_ITEM 13
+#define SCE_TXT2TAGS_OLIST_ITEM 14
+#define SCE_TXT2TAGS_BLOCKQUOTE 15
+#define SCE_TXT2TAGS_STRIKEOUT 16
+#define SCE_TXT2TAGS_HRULE 17
+#define SCE_TXT2TAGS_LINK 18
+#define SCE_TXT2TAGS_CODE 19
+#define SCE_TXT2TAGS_CODE2 20
+#define SCE_TXT2TAGS_CODEBK 21
+#define SCE_TXT2TAGS_COMMENT 22
+#define SCE_TXT2TAGS_OPTION 23
+#define SCE_TXT2TAGS_PREPROC 24
+#define SCE_TXT2TAGS_POSTPROC 25
 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */

 #endif
--- a/scintilla/include/Scintilla.h
+++ b/scintilla/include/Scintilla.h
@ -673,6 +673,9 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_FINDCOLUMN 2456
 #define SCI_GETCARETSTICKY 2457
 #define SCI_SETCARETSTICKY 2458
+#define SC_CARETSTICKY_OFF 0
+#define SC_CARETSTICKY_ON 1
+#define SC_CARETSTICKY_WHITESPACE 2
 #define SCI_TOGGLECARETSTICKY 2459
 #define SCI_SETPASTECONVERTENDINGS 2467
 #define SCI_GETPASTECONVERTENDINGS 2468
@ -787,6 +790,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETADDITIONALCARETFORE 2605
 #define SCI_ROTATESELECTION 2606
 #define SCI_SWAPMAINANCHORCARET 2607
+#define SCI_CHANGELEXERSTATE 2617
 #define SCI_STARTRECORD 3001
 #define SCI_STOPRECORD 3002
 #define SCI_SETLEXER 4001
@ -802,6 +806,14 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETPROPERTYINT 4010
 #define SCI_GETSTYLEBITSNEEDED 4011
 #define SCI_GETLEXERLANGUAGE 4012
+#define SCI_PRIVATELEXERCALL 4013
+#define SCI_PROPERTYNAMES 4014
+#define SC_TYPE_BOOLEAN 0
+#define SC_TYPE_INTEGER 1
+#define SC_TYPE_STRING 2
+#define SCI_PROPERTYTYPE 4015
+#define SCI_DESCRIBEPROPERTY 4016
+#define SCI_DESCRIBEKEYWORDSETS 4017
 #define SC_MOD_INSERTTEXT 0x1
 #define SC_MOD_DELETETEXT 0x2
 #define SC_MOD_CHANGESTYLE 0x4
@ -821,8 +833,11 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_MOD_CHANGEMARGIN 0x10000
 #define SC_MOD_CHANGEANNOTATION 0x20000
 #define SC_MOD_CONTAINER 0x40000
-#define SC_MODEVENTMASKALL 0x7FFFF
+#define SC_MOD_LEXERSTATE 0x80000
+#define SC_MODEVENTMASKALL 0xFFFFF
+
 #define SC_SEARCHRESULT_LINEBUFFERMAXLENGTH 1024
+
 #define SCEN_CHANGE 768
 #define SCEN_SETFOCUS 512
 #define SCEN_KILLFOCUS 256
--- a/scintilla/include/Scintilla.iface
+++ b/scintilla/include/Scintilla.iface
@ -1780,10 +1780,15 @@ fun int EncodedFromUTF8=2449(string utf8, stringresult encoded)
 fun int FindColumn=2456(int line, int column)

 # Can the caret preferred x position only be changed by explicit movement commands?
-get bool GetCaretSticky=2457(,)
+get int GetCaretSticky=2457(,)

 # Stop the caret preferred x position changing when the user types.
-set void SetCaretSticky=2458(bool useCaretStickyBehaviour,)
+set void SetCaretSticky=2458(int useCaretStickyBehaviour,)
+
+enu CaretSticky=SC_CARETSTICKY_
+val SC_CARETSTICKY_OFF=0
+val SC_CARETSTICKY_ON=1
+val SC_CARETSTICKY_WHITESPACE=2

 # Switch between sticky and non-sticky: meant to be bound to a key.
 fun void ToggleCaretSticky=2459(,)
@ -2084,6 +2089,10 @@ fun void RotateSelection=2606(,)
 # Swap that caret and anchor of the main selection.
 fun void SwapMainAnchorCaret=2607(,)

+# Indicate that the internal state of a lexer has changed over a range and therefore
+# there may be a need to redraw.
+fun int ChangeLexerState=2617(position start, position end)
+
 # Start notifying the container of all key presses and commands.
 fun void StartRecord=3001(,)

@ -2132,6 +2141,26 @@ get int GetStyleBitsNeeded=4011(,)
 # Return the length of the text.
 get int GetLexerLanguage=4012(, stringresult text)

+# For private communication between an application and a known lexer.
+fun int PrivateLexerCall=4013(int operation, int pointer)
+
+# Retrieve a '\n' separated list of properties understood by the current lexer.
+fun int PropertyNames=4014(, stringresult names)
+
+enu TypeProperty=SC_TYPE_
+val SC_TYPE_BOOLEAN=0
+val SC_TYPE_INTEGER=1
+val SC_TYPE_STRING=2
+
+# Retrieve the type of a property.
+fun int PropertyType=4015(string name,)
+
+# Describe a property.
+fun int DescribeProperty=4016(string name, stringresult description)
+
+# Retrieve a '\n' separated list of descriptions of the keyword sets understood by the current lexer.
+fun int DescribeKeyWordSets=4017(, stringresult descriptions)
+
 # Notifications
 # Type of modification and the action which caused the modification.
 # These are defined as a bit mask to make it easy to specify which notifications are wanted.
@ -2156,7 +2185,8 @@ val SC_MOD_CHANGELINESTATE=0x8000
 val SC_MOD_CHANGEMARGIN=0x10000
 val SC_MOD_CHANGEANNOTATION=0x20000
 val SC_MOD_CONTAINER=0x40000
-val SC_MODEVENTMASKALL=0x7FFFF
+val SC_MOD_LEXERSTATE=0x80000
+val SC_MODEVENTMASKALL=0xFFFFF

 # For compatibility, these go through the COMMAND notification rather than NOTIFY
 # and should have had exactly the same values as the EN_* constants.
@ -2299,6 +2329,7 @@ val SCLEX_POWERPRO=95
 val SCLEX_NIMROD=96
 val SCLEX_SML=97
 val SCLEX_MARKDOWN=98
+val SCLEX_TXT2TAGS=99

 # When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
 # value assigned in sequence from SCLEX_AUTOMATIC+1.
@ -3628,6 +3659,9 @@ val SCE_POWERSHELL_IDENTIFIER=7
 val SCE_POWERSHELL_KEYWORD=8
 val SCE_POWERSHELL_CMDLET=9
 val SCE_POWERSHELL_ALIAS=10
+val SCE_POWERSHELL_FUNCTION=11
+val SCE_POWERSHELL_USER1=12
+val SCE_POWERSHELL_COMMENTSTREAM=13
 # Lexical state for SCLEX_MYSQL
 lex MySQL=SCLEX_MYSQL SCE_MYSQL_
 val SCE_MYSQL_DEFAULT=0
@ -3752,6 +3786,34 @@ val SCE_MARKDOWN_LINK=18
 val SCE_MARKDOWN_CODE=19
 val SCE_MARKDOWN_CODE2=20
 val SCE_MARKDOWN_CODEBK=21
+# Lexical state for SCLEX_TXT2TAGS
+lex Txt2tags=SCLEX_TXT2TAGS SCE_TXT2TAGS_
+val SCE_TXT2TAGS_DEFAULT=0
+val SCE_TXT2TAGS_LINE_BEGIN=1
+val SCE_TXT2TAGS_STRONG1=2
+val SCE_TXT2TAGS_STRONG2=3
+val SCE_TXT2TAGS_EM1=4
+val SCE_TXT2TAGS_EM2=5
+val SCE_TXT2TAGS_HEADER1=6
+val SCE_TXT2TAGS_HEADER2=7
+val SCE_TXT2TAGS_HEADER3=8
+val SCE_TXT2TAGS_HEADER4=9
+val SCE_TXT2TAGS_HEADER5=10
+val SCE_TXT2TAGS_HEADER6=11
+val SCE_TXT2TAGS_PRECHAR=12
+val SCE_TXT2TAGS_ULIST_ITEM=13
+val SCE_TXT2TAGS_OLIST_ITEM=14
+val SCE_TXT2TAGS_BLOCKQUOTE=15
+val SCE_TXT2TAGS_STRIKEOUT=16
+val SCE_TXT2TAGS_HRULE=17
+val SCE_TXT2TAGS_LINK=18
+val SCE_TXT2TAGS_CODE=19
+val SCE_TXT2TAGS_CODE2=20
+val SCE_TXT2TAGS_CODEBK=21
+val SCE_TXT2TAGS_COMMENT=22
+val SCE_TXT2TAGS_OPTION=23
+val SCE_TXT2TAGS_PREPROC=24
+val SCE_TXT2TAGS_POSTPROC=25

 # Events

--- a/scintilla/include/WindowAccessor.h
+++ b/scintilla/include/WindowAccessor.h
@ -1,67 +0,0 @@
-// Scintilla source code edit control
-/** @file WindowAccessor.h
- ** Implementation of BufferAccess and StylingAccess on a Scintilla
- ** rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-/**
- */
-
-class WindowAccessor : public Accessor {
-	// Private so WindowAccessor objects can not be copied
-	WindowAccessor(const WindowAccessor &source) : Accessor(), props(source.props) {}
-	WindowAccessor &operator=(const WindowAccessor &) { return *this; }
-protected:
-	WindowID id;
-	PropertyGet &props;
-	int lenDoc;
-
-	char styleBuf[bufferSize];
-	int validLen;
-	char chFlags;
-	char chWhile;
-	unsigned int startSeg;
-
-	bool InternalIsLeadByte(char ch);
-	void Fill(int position);
-public:
-	WindowAccessor(WindowID id_, PropertyGet &props_) : 
-		Accessor(), id(id_), props(props_), 
-		lenDoc(-1), validLen(0), chFlags(0), chWhile(0) {
-	}
-	~WindowAccessor();
-	bool Match(int pos, const char *s);
-	char StyleAt(int position);
-	int GetLine(int position);
-	int LineStart(int line);
-	int LevelAt(int line);
-	int Length();
-	void Flush();
-	int GetLineState(int line);
-	int SetLineState(int line, int state);
-	int GetPropertyInt(const char *key, int defaultValue=0) { 
-		return props.GetInt(key, defaultValue); 
-	}
-	char *GetProperties() {
-		return props.ToString();
-	}
-
-	void StartAt(unsigned int start, char chMask=31);
-	void SetFlags(char chFlags_, char chWhile_) {chFlags = chFlags_; chWhile = chWhile_; }
-	unsigned int GetStartSegment() { return startSeg; }
-	void StartSegment(unsigned int pos);
-	void ColourTo(unsigned int pos, int chAttr);
-	void SetLevel(int line, int level);
-	int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0);
-	void IndicatorFill(int start, int end, int indicator, int value);
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
--- a/scintilla/lexers/LexAPDL.cxx
+++ b/scintilla/lexers/LexAPDL.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexASY.cxx
+++ b/scintilla/lexers/LexASY.cxx
@ -4,19 +4,21 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexAU3.cxx
+++ b/scintilla/lexers/LexAU3.cxx
@ -52,19 +52,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexAVE.cxx
+++ b/scintilla/lexers/LexAVE.cxx
@ -9,19 +9,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexAbaqus.cxx
+++ b/scintilla/lexers/LexAbaqus.cxx
@ -10,19 +10,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexAda.cxx
+++ b/scintilla/lexers/LexAda.cxx
@ -6,19 +6,24 @@
 // The License.txt file describes the conditions under which this software may be distributed.

 #include <stdlib.h>
-#include <ctype.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>

 #include <string>

-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"

+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "PropSet.h"
-#include "KeyWords.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"

 #ifdef SCI_NAMESPACE
 using namespace Scintilla;
--- a/scintilla/lexers/LexAsm.cxx
+++ b/scintilla/lexers/LexAsm.cxx
@ -10,19 +10,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexAsn1.cxx
+++ b/scintilla/lexers/LexAsn1.cxx
@ -5,21 +5,25 @@
 // Copyright 2004 by Herr Pfarrer rpfarrer <at> yahoo <dot> de
 // Last Updated: 20/07/2004
 // The License.txt file describes the conditions under which this software may be distributed.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexBaan.cxx
+++ b/scintilla/lexers/LexBaan.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexBash.cxx
+++ b/scintilla/lexers/LexBash.cxx
@ -2,25 +2,27 @@
 /** @file LexBash.cxx
 ** Lexer for Bash.
 **/
-// Copyright 2004-2008 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 2004-2010 by Neil Hodgson <neilh@scintilla.org>
 // Adapted from LexPerl by Kein-Hong Man 2004
 // The License.txt file describes the conditions under which this software may be distributed.

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
@ -40,6 +42,14 @@ using namespace Scintilla;
 #define	BASH_BASE_OCTAL_ERROR	69
 #endif

+// state constants for parts of a bash command segment
+#define	BASH_CMD_BODY			0
+#define BASH_CMD_START			1
+#define BASH_CMD_WORD			2
+#define BASH_CMD_TEST			3
+#define BASH_CMD_ARITH			4
+#define BASH_CMD_DELIM			5
+
 static inline int translateBashDigit(int ch) {
 	if (ch >= '0' && ch <= '9') {
 		return ch - '0';
@ -80,11 +90,15 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 							 WordList *keywordlists[], Accessor &styler) {

 	WordList &keywords = *keywordlists[0];
+	WordList cmdDelimiter, bashStruct, bashStruct_in;
+	cmdDelimiter.Set("| || |& & && ; ;; ( ) { }");
+	bashStruct.Set("if elif fi while until else then do done esac eval");
+	bashStruct_in.Set("for case select");

 	CharacterSet setWordStart(CharacterSet::setAlpha, "_");
 	// note that [+-] are often parts of identifiers in shell scripts
 	CharacterSet setWord(CharacterSet::setAlphaNum, "._+-");
-	CharacterSet setBashOperator(CharacterSet::setNone, "^&\\%()-+=|{}[]:;>,*/<?!.~@");
+	CharacterSet setBashOperator(CharacterSet::setNone, "^&%()-+=|{}[]:;>,*/<?!.~@");
 	CharacterSet setSingleCharOp(CharacterSet::setNone, "rwxoRWXOezsfdlpSbctugkTBMACahGLNn");
 	CharacterSet setParam(CharacterSet::setAlphaNum, "$_");
 	CharacterSet setHereDoc(CharacterSet::setAlpha, "_\\-+!");
@ -144,46 +158,115 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 	int numBase = 0;
 	int digit;
 	unsigned int endPos = startPos + length;
+	int cmdState = BASH_CMD_START;
+	int testExprType = 0;

-	// Backtrack to beginning of style if required...
-	// If in a long distance lexical state, backtrack to find quote characters
-	if (initStyle == SCE_SH_HERE_Q) {
-		while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_SH_HERE_DELIM)) {
-			startPos--;
-		}
-		startPos = styler.LineStart(styler.GetLine(startPos));
-		initStyle = styler.StyleAt(startPos - 1);
-	}
-	// Bash strings can be multi-line with embedded newlines, so backtrack.
-	// Bash numbers have additional state during lexing, so backtrack too.
-	if (initStyle == SCE_SH_STRING
-	 || initStyle == SCE_SH_BACKTICKS
-	 || initStyle == SCE_SH_CHARACTER
-	 || initStyle == SCE_SH_NUMBER
-	 || initStyle == SCE_SH_IDENTIFIER
-	 || initStyle == SCE_SH_COMMENTLINE) {
-		while ((startPos > 1) && (styler.StyleAt(startPos - 1) == initStyle)) {
-			startPos--;
+	// Always backtracks to the start of a line that is not a continuation
+	// of the previous line (i.e. start of a bash command segment)
+	int ln = styler.GetLine(startPos);
+	for (;;) {
+		startPos = styler.LineStart(ln);
+		if (ln == 0 || styler.GetLineState(ln) == BASH_CMD_START)
+			break;
+		ln--;
 	}
 	initStyle = SCE_SH_DEFAULT;
-	}

 	StyleContext sc(startPos, endPos - startPos, initStyle, styler);

 	for (; sc.More(); sc.Forward()) {

+		// handle line continuation, updates per-line stored state
+		if (sc.atLineStart) {
+			ln = styler.GetLine(sc.currentPos);
+			if (sc.state == SCE_SH_STRING
+			 || sc.state == SCE_SH_BACKTICKS
+			 || sc.state == SCE_SH_CHARACTER
+			 || sc.state == SCE_SH_HERE_Q
+			 || sc.state == SCE_SH_COMMENTLINE
+			 || sc.state == SCE_SH_PARAM) {
+				// force backtrack while retaining cmdState
+				styler.SetLineState(ln, BASH_CMD_BODY);
+			} else {
+				if (ln > 0) {
+					if ((sc.GetRelative(-3) == '\\' && sc.GetRelative(-2) == '\r' && sc.chPrev == '\n')
+					 || sc.GetRelative(-2) == '\\') {	// handle '\' line continuation
+						// retain last line's state
+					} else
+						cmdState = BASH_CMD_START;
+				}
+				styler.SetLineState(ln, cmdState);
+			}
+		}
+
+		// controls change of cmdState at the end of a non-whitespace element
+		// states BODY|TEST|ARITH persist until the end of a command segment
+		// state WORD persist, but ends with 'in' or 'do' construct keywords
+		int cmdStateNew = BASH_CMD_BODY;
+		if (cmdState == BASH_CMD_TEST || cmdState == BASH_CMD_ARITH || cmdState == BASH_CMD_WORD)
+			cmdStateNew = cmdState;
+		int stylePrev = sc.state;
+
 		// Determine if the current state should terminate.
 		switch (sc.state) {
 			case SCE_SH_OPERATOR:
 				sc.SetState(SCE_SH_DEFAULT);
+				if (cmdState == BASH_CMD_DELIM)		// if command delimiter, start new command
+					cmdStateNew = BASH_CMD_START;
+				else if (sc.chPrev == '\\')			// propagate command state if line continued
+					cmdStateNew = cmdState;
 				break;
 			case SCE_SH_WORD:
 				// "." never used in Bash variable names but used in file names
 				if (!setWord.Contains(sc.ch)) {
-					char s[1000];
+					char s[500];
+					char s2[10];
 					sc.GetCurrent(s, sizeof(s));
-					if (s[0] != '-' &&	// for file operators
-						!keywords.InList(s)) {
+					// allow keywords ending in a whitespace or command delimiter
+					s2[0] = static_cast<char>(sc.ch);
+					s2[1] = '\0';
+					bool keywordEnds = IsASpace(sc.ch) || cmdDelimiter.InList(s2);
+					// 'in' or 'do' may be construct keywords
+					if (cmdState == BASH_CMD_WORD) {
+						if (strcmp(s, "in") == 0 && keywordEnds)
+							cmdStateNew = BASH_CMD_BODY;
+						else if (strcmp(s, "do") == 0 && keywordEnds)
+							cmdStateNew = BASH_CMD_START;
+						else
+							sc.ChangeState(SCE_SH_IDENTIFIER);
+						sc.SetState(SCE_SH_DEFAULT);
+						break;
+					}
+					// a 'test' keyword starts a test expression
+					if (strcmp(s, "test") == 0) {
+						if (cmdState == BASH_CMD_START && keywordEnds) {
+							cmdStateNew = BASH_CMD_TEST;
+							testExprType = 0;
+						} else
+							sc.ChangeState(SCE_SH_IDENTIFIER);
+					}
+					// detect bash construct keywords
+					else if (bashStruct.InList(s)) {
+						if (cmdState == BASH_CMD_START && keywordEnds)
+							cmdStateNew = BASH_CMD_START;
+						else
+							sc.ChangeState(SCE_SH_IDENTIFIER);
+					}
+					// 'for'|'case'|'select' needs 'in'|'do' to be highlighted later
+					else if (bashStruct_in.InList(s)) {
+						if (cmdState == BASH_CMD_START && keywordEnds)
+							cmdStateNew = BASH_CMD_WORD;
+						else
+							sc.ChangeState(SCE_SH_IDENTIFIER);
+					}
+					// disambiguate option items and file test operators
+					else if (s[0] == '-') {
+						if (cmdState != BASH_CMD_TEST)
+							sc.ChangeState(SCE_SH_IDENTIFIER);
+					}
+					// disambiguate keywords and identifiers
+					else if (cmdState != BASH_CMD_START
+						  || !(keywords.InList(s) && keywordEnds)) {
 						sc.ChangeState(SCE_SH_IDENTIFIER);
 					}
 					sc.SetState(SCE_SH_DEFAULT);
@ -376,10 +459,17 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 			sc.SetState(SCE_SH_HERE_Q);
 		}

+		// update cmdState about the current command segment
+		if (stylePrev != SCE_SH_DEFAULT && sc.state == SCE_SH_DEFAULT) {
+			cmdState = cmdStateNew;
+		}
 		// Determine if a new state should be entered.
 		if (sc.state == SCE_SH_DEFAULT) {
-			if (sc.ch == '\\') {	// escaped character
+			if (sc.ch == '\\') {
+				// Bash can escape any non-newline as a literal
 				sc.SetState(SCE_SH_IDENTIFIER);
+				if (sc.chNext == '\r' || sc.chNext == '\n')
+					sc.SetState(SCE_SH_OPERATOR);
 			} else if (IsADigit(sc.ch)) {
 				sc.SetState(SCE_SH_NUMBER);
 				numBase = BASH_BASE_DECIMAL;
@ -409,6 +499,10 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 				sc.SetState(SCE_SH_BACKTICKS);
 				Quote.Start(sc.ch);
 			} else if (sc.ch == '$') {
+				if (sc.Match("$((")) {
+					sc.SetState(SCE_SH_OPERATOR);	// handle '((' later
+					continue;
+				}
 				sc.SetState(SCE_SH_SCALAR);
 				sc.Forward();
 				if (sc.ch == '{') {
@ -419,9 +513,6 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 					sc.ChangeState(SCE_SH_STRING);
 				} else if (sc.ch == '(' || sc.ch == '`') {
 					sc.ChangeState(SCE_SH_BACKTICKS);
-					if (sc.chNext == '(') {	// $(( is lexed as operator
-						sc.ChangeState(SCE_SH_OPERATOR);
-					}
 				} else {
 					continue;	// scalar has no delimiter pair
 				}
@ -438,9 +529,66 @@ static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
 				sc.SetState(SCE_SH_WORD);
 				sc.Forward();
 			} else if (setBashOperator.Contains(sc.ch)) {
+				char s[10];
+				bool isCmdDelim = false;
 				sc.SetState(SCE_SH_OPERATOR);
+				// handle opening delimiters for test/arithmetic expressions - ((,[[,[
+				if (cmdState == BASH_CMD_START
+				 || cmdState == BASH_CMD_BODY) {
+					if (sc.Match('(', '(')) {
+						cmdState = BASH_CMD_ARITH;
+						sc.Forward();
+					} else if (sc.Match('[', '[') && IsASpace(sc.GetRelative(2))) {
+						cmdState = BASH_CMD_TEST;
+						testExprType = 1;
+						sc.Forward();
+					} else if (sc.ch == '[' && IsASpace(sc.chNext)) {
+						cmdState = BASH_CMD_TEST;
+						testExprType = 2;
 					}
 				}
+				// special state -- for ((x;y;z)) in ... looping
+				if (cmdState == BASH_CMD_WORD && sc.Match('(', '(')) {
+					cmdState = BASH_CMD_ARITH;
+					sc.Forward();
+					continue;
+				}
+				// handle command delimiters in command START|BODY|WORD state, also TEST if 'test'
+				if (cmdState == BASH_CMD_START
+				 || cmdState == BASH_CMD_BODY
+				 || cmdState == BASH_CMD_WORD
+				 || (cmdState == BASH_CMD_TEST && testExprType == 0)) {
+					s[0] = static_cast<char>(sc.ch);
+					if (setBashOperator.Contains(sc.chNext)) {
+						s[1] = static_cast<char>(sc.chNext);
+						s[2] = '\0';
+						isCmdDelim = cmdDelimiter.InList(s);
+						if (isCmdDelim)
+							sc.Forward();
+					}
+					if (!isCmdDelim) {
+						s[1] = '\0';
+						isCmdDelim = cmdDelimiter.InList(s);
+					}
+					if (isCmdDelim) {
+						cmdState = BASH_CMD_DELIM;
+						continue;
+					}
+				}
+				// handle closing delimiters for test/arithmetic expressions - )),]],]
+				if (cmdState == BASH_CMD_ARITH && sc.Match(')', ')')) {
+					cmdState = BASH_CMD_BODY;
+					sc.Forward();
+				} else if (cmdState == BASH_CMD_TEST && IsASpace(sc.chPrev)) {
+					if (sc.Match(']', ']') && testExprType == 1) {
+						sc.Forward();
+						cmdState = BASH_CMD_BODY;
+					} else if (sc.ch == ']' && testExprType == 2) {
+						cmdState = BASH_CMD_BODY;
+					}
+				}
+			}
+		}// sc.state
 	}
 	sc.Complete();
 }
--- a/scintilla/lexers/LexBasic.cxx
+++ b/scintilla/lexers/LexBasic.cxx
@ -19,18 +19,21 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <stdarg.h>
+#include <assert.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexBullant.cxx
+++ b/scintilla/lexers/LexBullant.cxx
@ -3,18 +3,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexCLW.cxx
+++ b/scintilla/lexers/LexCLW.cxx
@ -10,17 +10,21 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
 #include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexCOBOL.cxx
+++ b/scintilla/lexers/LexCOBOL.cxx
@ -10,18 +10,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
@ -90,11 +94,11 @@ static int classifyWordCOBOL(unsigned int start, unsigned int end, /*WordList &k
    getRange(start, end, styler, s, sizeof(s));

    char chAttr = SCE_C_IDENTIFIER;
-    if (isdigit(s[0]) || (s[0] == '.')) {
+    if (isdigit(s[0]) || (s[0] == '.') || (s[0] == 'v')) {
        chAttr = SCE_C_NUMBER;
 		char *p = s + 1;
 		while (*p) {
-			if (!isdigit(*p) && isCOBOLwordchar(*p)) {
+			if ((!isdigit(*p) && (*p) != 'v') && isCOBOLwordchar(*p)) {
 				chAttr = SCE_C_IDENTIFIER;
 			    break;
 			}
--- a/scintilla/lexers/LexCPP.cxx
+++ b/scintilla/lexers/LexCPP.cxx
--- a/scintilla/lexers/LexCSS.cxx
+++ b/scintilla/lexers/LexCSS.cxx
@ -9,19 +9,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexCaml.cxx
+++ b/scintilla/lexers/LexCaml.cxx
@ -20,20 +20,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "PropSetSimple.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 //	Since the Microsoft __iscsym[f] funcs are not ANSI...
 inline int  iscaml(int c) {return isalnum(c) || c == '_';}
 inline int iscamlf(int c) {return isalpha(c) || c == '_';}
@ -51,9 +54,13 @@ using namespace Scintilla;
 /*
 	(actually seems to work!)
 */
+#include <string>
 #include "WindowAccessor.h"
 #include "ExternalLexer.h"

+#undef EXT_LEXER_DECL
+#define EXT_LEXER_DECL __declspec( dllexport ) __stdcall
+
 #if PLAT_WIN
 #include <windows.h>
 #endif
--- a/scintilla/lexers/LexCmake.cxx
+++ b/scintilla/lexers/LexCmake.cxx
@ -5,21 +5,26 @@
 // Copyright 2007 by Cristian Adam <cristian [dot] adam [at] gmx [dot] net>
 // based on the NSIS lexer
 // The License.txt file describes the conditions under which this software may be distributed.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "CharClassify.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexConf.cxx
+++ b/scintilla/lexers/LexConf.cxx
@ -11,18 +11,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexCrontab.cxx
+++ b/scintilla/lexers/LexCrontab.cxx
@ -9,18 +9,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexCsound.cxx
+++ b/scintilla/lexers/LexCsound.cxx
@ -8,18 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
-#include "Platform.h"
+#include <assert.h>
+#include <ctype.h>

-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexD.cxx
+++ b/scintilla/lexers/LexD.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexEScript.cxx
+++ b/scintilla/lexers/LexEScript.cxx
@ -9,16 +9,20 @@
 #include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexEiffel.cxx
+++ b/scintilla/lexers/LexEiffel.cxx
@ -7,19 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexErlang.cxx
+++ b/scintilla/lexers/LexErlang.cxx
@ -10,18 +10,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexFlagship.cxx
+++ b/scintilla/lexers/LexFlagship.cxx
@ -10,19 +10,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexForth.cxx
+++ b/scintilla/lexers/LexForth.cxx
@ -7,19 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexFortran.cxx
+++ b/scintilla/lexers/LexFortran.cxx
@ -8,18 +8,24 @@
 /***************************************/
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 /***************************************/
-#include "Platform.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexGAP.cxx
+++ b/scintilla/lexers/LexGAP.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexGui4Cli.cxx
+++ b/scintilla/lexers/LexGui4Cli.cxx
@ -23,19 +23,23 @@ val SCE_GC_OPERATOR=9

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexHTML.cxx
+++ b/scintilla/lexers/LexHTML.cxx
@ -7,19 +7,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
@ -54,13 +57,6 @@ inline bool IsOperator(int ch) {
 	return false;
 }

-static inline int MakeLowerCase(int ch) {
-	if (ch < 'A' || ch > 'Z')
-		return ch;
-	else
-		return ch - 'A' + 'a';
-}
-
 static void GetTextSegment(Accessor &styler, unsigned int start, unsigned int end, char *s, size_t len) {
 	size_t i = 0;
 	for (; (i < end - start + 1) && (i < len-1); i++) {
@ -889,6 +885,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		else if ((state != SCE_H_ASPAT) &&
 		         !isPHPStringState(state) &&
 		         (state != SCE_HPHP_COMMENT) &&
+		         (state != SCE_HPHP_COMMENTLINE) &&
 		         (ch == '<') &&
 		         (chNext == '?') &&
 				 !IsScriptCommentState(state) ) {
--- a/scintilla/lexers/LexHaskell.cxx
+++ b/scintilla/lexers/LexHaskell.cxx
@ -18,20 +18,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "PropSetSimple.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexInno.cxx
+++ b/scintilla/lexers/LexInno.cxx
@ -7,20 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "CharClassify.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexKix.cxx
+++ b/scintilla/lexers/LexKix.cxx
@ -7,19 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexLisp.cxx
+++ b/scintilla/lexers/LexLisp.cxx
@ -8,18 +8,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
@ -44,7 +48,7 @@ static inline bool isLispwordstart(char ch) {


 static void classifyWordLisp(unsigned int start, unsigned int end, WordList &keywords, WordList &keywords_kw, Accessor &styler) {
-	PLATFORM_ASSERT(end >= start);
+	assert(end >= start);
 	char s[100];
 	unsigned int i;
 	bool digit_flag = true;
--- a/scintilla/lexers/LexLout.cxx
+++ b/scintilla/lexers/LexLout.cxx
@ -7,19 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexLua.cxx
+++ b/scintilla/lexers/LexLua.cxx
@ -9,19 +9,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexMMIXAL.cxx
+++ b/scintilla/lexers/LexMMIXAL.cxx
@ -9,19 +9,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexMPT.cxx
+++ b/scintilla/lexers/LexMPT.cxx
@ -7,21 +7,26 @@
 // Copyright 2003 by Marius Gheorghe <mgheorghe@cabletest.com>
 // The License.txt file describes the conditions under which this software may be distributed.

+#include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
+#include <stdarg.h>
+#include <assert.h>

 #include <string>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexMSSQL.cxx
+++ b/scintilla/lexers/LexMSSQL.cxx
@ -7,18 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexMagik.cxx
+++ b/scintilla/lexers/LexMagik.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexMarkdown.cxx
+++ b/scintilla/lexers/LexMarkdown.cxx
@ -36,19 +36,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexMatlab.cxx
+++ b/scintilla/lexers/LexMatlab.cxx
@ -12,19 +12,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexMetapost.cxx
+++ b/scintilla/lexers/LexMetapost.cxx
@ -14,18 +14,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexMySQL.cxx
+++ b/scintilla/lexers/LexMySQL.cxx
@ -12,19 +12,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexNimrod.cxx
+++ b/scintilla/lexers/LexNimrod.cxx
@ -9,19 +9,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
@ -378,7 +382,7 @@ static void FoldNimrodDoc(unsigned int startPos, int length,

 		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
 		const int levelBeforeComments =
-		    Platform::Maximum(indentCurrentLevel,levelAfterComments);
+		    Maximum(indentCurrentLevel,levelAfterComments);

 		// Now set all the indent levels on the lines we skipped
 		// Do this from end to start.  Once we encounter one line
--- a/scintilla/lexers/LexNsis.cxx
+++ b/scintilla/lexers/LexNsis.cxx
@ -5,21 +5,26 @@
 // Copyright 2003 - 2005 by Angelo Mandato <angelo [at] spaceblue [dot] com>
 // Last Updated: 03/13/2005
 // The License.txt file describes the conditions under which this software may be distributed.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "CharClassify.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexObjC.cxx
+++ b/scintilla/lexers/LexObjC.cxx
--- a/scintilla/lexers/LexOpal.cxx
+++ b/scintilla/lexers/LexOpal.cxx
@ -6,18 +6,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexOthers.cxx
+++ b/scintilla/lexers/LexOthers.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "CharClassify.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexPB.cxx
+++ b/scintilla/lexers/LexPB.cxx
@ -35,19 +35,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexPLM.cxx
+++ b/scintilla/lexers/LexPLM.cxx
@ -4,18 +4,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexPOV.cxx
+++ b/scintilla/lexers/LexPOV.cxx
@ -16,19 +16,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexPS.cxx
+++ b/scintilla/lexers/LexPS.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexPascal.cxx
+++ b/scintilla/lexers/LexPascal.cxx
@ -109,19 +109,22 @@ contains requires

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexPerl.cxx
+++ b/scintilla/lexers/LexPerl.cxx
@ -8,19 +8,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
@ -1181,6 +1184,26 @@ static bool IsCommentLine(int line, Accessor &styler) {
 	return false;
 }

+static bool IsPackageLine(int line, Accessor &styler) {
+	int pos = styler.LineStart(line);
+	int style = styler.StyleAt(pos);
+	if (style == SCE_PL_WORD && styler.Match(pos, "package")) {
+		return true;
+	}
+	return false;
+}
+
+static int PodHeadingLevel(int pos, Accessor &styler) {
+	int lvl = static_cast<unsigned char>(styler.SafeGetCharAt(pos + 5));
+	if (lvl >= '1' && lvl <= '4') {
+		return lvl - '0';
+	}
+	return 0;
+}
+
+#define PERL_HEADFOLD_SHIFT		4
+#define PERL_HEADFOLD_MASK		0xF0
+
 static void FoldPerlDoc(unsigned int startPos, int length, int, WordList *[],
                        Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
@ -1207,7 +1230,7 @@ static void FoldPerlDoc(unsigned int startPos, int length, int, WordList *[],
 	int styleNext = styler.StyleAt(startPos);
 	// Used at end of line to determine if the line was a package definition
 	bool isPackageLine = false;
-	bool isPodHeading = false;
+	int podHeading = 0;
 	for (unsigned int i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
@ -1225,49 +1248,58 @@ static void FoldPerlDoc(unsigned int startPos, int length, int, WordList *[],
 					 && !IsCommentLine(lineCurrent + 1, styler))
 				levelCurrent--;
 		}
+		// {} [] block folding
 		if (style == SCE_PL_OPERATOR) {
 			if (ch == '{') {
 				levelCurrent++;
 			} else if (ch == '}') {
 				levelCurrent--;
 			}
+			if (ch == '[') {
+				levelCurrent++;
+			} else if (ch == ']') {
+				levelCurrent--;
 			}
-		// Custom POD folding
+		}
+		// POD folding
 		if (foldPOD && atLineStart) {
 			int stylePrevCh = (i) ? styler.StyleAt(i - 1):SCE_PL_DEFAULT;
 			if (style == SCE_PL_POD) {
 				if (stylePrevCh != SCE_PL_POD && stylePrevCh != SCE_PL_POD_VERB)
 					levelCurrent++;
 				else if (styler.Match(i, "=cut"))
-					levelCurrent--;
+					levelCurrent = (levelCurrent & ~PERL_HEADFOLD_MASK) - 1;
 				else if (styler.Match(i, "=head"))
-					isPodHeading = true;
+					podHeading = PodHeadingLevel(i, styler);
 			} else if (style == SCE_PL_DATASECTION) {
 				if (ch == '=' && isascii(chNext) && isalpha(chNext) && levelCurrent == SC_FOLDLEVELBASE)
 					levelCurrent++;
 				else if (styler.Match(i, "=cut") && levelCurrent > SC_FOLDLEVELBASE)
-					levelCurrent--;
+					levelCurrent = (levelCurrent & ~PERL_HEADFOLD_MASK) - 1;
 				else if (styler.Match(i, "=head"))
-					isPodHeading = true;
+					podHeading = PodHeadingLevel(i, styler);
 				// if package used or unclosed brace, level > SC_FOLDLEVELBASE!
 				// reset needed as level test is vs. SC_FOLDLEVELBASE
-				else if (styler.Match(i, "__END__"))
+				else if (stylePrevCh != SCE_PL_DATASECTION)
 					levelCurrent = SC_FOLDLEVELBASE;
 			}
 		}
-		// Custom package folding
+		// package folding
 		if (foldPackage && atLineStart) {
-			if (style == SCE_PL_WORD && styler.Match(i, "package")) {
+			if (IsPackageLine(lineCurrent, styler)
+				&& !IsPackageLine(lineCurrent + 1, styler))
 				isPackageLine = true;
 		}
-		}

 		if (atEOL) {
 			int lev = levelPrev;
-			if (isPodHeading) {
-				lev = levelPrev - 1;
+			// POD headings occupy bits 7-4, leaving some breathing room for
+			// non-standard practice -- POD sections stuck in blocks, etc.
+			if (podHeading > 0) {
+				levelCurrent = (lev & ~PERL_HEADFOLD_MASK) | (podHeading << PERL_HEADFOLD_SHIFT);
+				lev = levelCurrent - 1;
 				lev |= SC_FOLDLEVELHEADERFLAG;
-				isPodHeading = false;
+				podHeading = 0;
 			}
 			// Check if line was a package declaration
 			// because packages need "special" treatment
--- a/scintilla/lexers/LexPowerPro.cxx
+++ b/scintilla/lexers/LexPowerPro.cxx
@ -25,20 +25,24 @@
 // Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.

-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexPowerShell.cxx
+++ b/scintilla/lexers/LexPowerShell.cxx
@ -7,19 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
@ -35,6 +39,8 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 	WordList &keywords = *keywordlists[0];
 	WordList &keywords2 = *keywordlists[1];
 	WordList &keywords3 = *keywordlists[2];
+	WordList &keywords4 = *keywordlists[3];
+	WordList &keywords5 = *keywordlists[4];

 	styler.StartAt(startPos);

@ -46,6 +52,10 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 			if (sc.atLineEnd) {
 				sc.SetState(SCE_POWERSHELL_DEFAULT);
 			}
+		} else if (sc.state == SCE_POWERSHELL_COMMENTSTREAM) {
+			if (sc.ch == '>' && sc.chPrev == '#') {
+				sc.ForwardSetState(SCE_POWERSHELL_DEFAULT);
+			}
 		} else if (sc.state == SCE_POWERSHELL_STRING) {
 			// This is a doubles quotes string
 			if (sc.ch == '\"') {
@ -79,6 +89,10 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 					sc.ChangeState(SCE_POWERSHELL_CMDLET);
 				} else if (keywords3.InList(s)) {
 					sc.ChangeState(SCE_POWERSHELL_ALIAS);
+				} else if (keywords4.InList(s)) {
+					sc.ChangeState(SCE_POWERSHELL_FUNCTION);
+				} else if (keywords5.InList(s)) {
+					sc.ChangeState(SCE_POWERSHELL_USER1);
 				}
 				sc.SetState(SCE_POWERSHELL_DEFAULT);
 			}
@ -88,6 +102,8 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 		if (sc.state == SCE_POWERSHELL_DEFAULT) {
 			if (sc.ch == '#') {
 				sc.SetState(SCE_POWERSHELL_COMMENT);
+			} else if (sc.ch == '<' && sc.chNext == '#') {
+				sc.SetState(SCE_POWERSHELL_COMMENTSTREAM);
 			} else if (sc.ch == '\"') {
 				sc.SetState(SCE_POWERSHELL_STRING);
 			} else if (sc.ch == '\'') {
@ -109,8 +125,9 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 // 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 FoldPowerShellDoc(unsigned int startPos, int length, int,
+static void FoldPowerShellDoc(unsigned int startPos, int length, int initStyle,
                           WordList *[], Accessor &styler) {
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
 	unsigned int endPos = startPos + length;
@ -123,10 +140,12 @@ static void FoldPowerShellDoc(unsigned int startPos, int length, int,
 	int levelNext = levelCurrent;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
 	for (unsigned int i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
-		int style = styleNext;
+		int stylePrev = style;
+		style = styleNext;
 		styleNext = styler.StyleAt(i + 1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 		if (style == SCE_POWERSHELL_OPERATOR) {
@ -140,6 +159,12 @@ static void FoldPowerShellDoc(unsigned int startPos, int length, int,
 			} else if (ch == '}') {
 				levelNext--;
 			}
+		} else if (foldComment && style == SCE_POWERSHELL_COMMENTSTREAM) {
+			if (stylePrev != SCE_POWERSHELL_COMMENTSTREAM) {
+				levelNext++;
+			} else if (styleNext != SCE_POWERSHELL_COMMENTSTREAM) {
+				levelNext--;
+			}
 		}
 		if (!IsASpace(ch))
 			visibleChars++;
@ -168,6 +193,8 @@ static const char * const powershellWordLists[] = {
 	"Commands",
 	"Cmdlets",
 	"Aliases",
+	"Functions",
+	"User1",
 	0
 };

--- a/scintilla/lexers/LexProgress.cxx
+++ b/scintilla/lexers/LexProgress.cxx
@ -13,19 +13,23 @@ Support more than 6 comments levels
 **/
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexPython.cxx
+++ b/scintilla/lexers/LexPython.cxx
@ -7,19 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
@ -507,7 +511,7 @@ static void FoldPyDoc(unsigned int startPos, int length, int /*initStyle - unuse
 		}

 		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
-		const int levelBeforeComments = Platform::Maximum(indentCurrentLevel,levelAfterComments);
+		const int levelBeforeComments = Maximum(indentCurrentLevel,levelAfterComments);

 		// Now set all the indent levels on the lines we skipped
 		// Do this from end to start.  Once we encounter one line
--- a/scintilla/lexers/LexR.cxx
+++ b/scintilla/lexers/LexR.cxx
@ -8,19 +8,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexRebol.cxx
+++ b/scintilla/lexers/LexRebol.cxx
@ -13,18 +13,22 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.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;
--- a/scintilla/lexers/LexRuby.cxx
+++ b/scintilla/lexers/LexRuby.cxx
@ -7,18 +7,23 @@

 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.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
--- a/scintilla/lexers/LexSML.cxx
+++ b/scintilla/lexers/LexSML.cxx
@ -6,22 +6,25 @@
 // Modified from LexCaml.cxx by Robert Roessler <robertr@rftp.com> Copyright 2005
 // The License.txt file describes the conditions under which this software may be distributed.

-
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>

-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"

+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 inline int  issml(int c) {return isalnum(c) || c == '_';}
 inline int issmlf(int c) {return isalpha(c) || c == '_';}
 inline int issmld(int c) {return isdigit(c) || c == '_';}
--- a/Show More
+++ b/Show More