Fierelier/notepad-plus-plus-legacy
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[UPDATE] Update Scintilla from 2.12 to 2.20

Browse Source 
git-svn-id: svn://svn.tuxfamily.org/svnroot/notepadplus/repository/trunk@653 f5eea248-9336-0410-98b8-ebc06183d4e3
This commit is contained in:
Don Ho 2010-08-21 23:59:56 +00:00
parent 46c3286077
commit d4d42f8a1a
188 changed files with 13919 additions and 10468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
scintilla/cocoa/Framework.mk
View File

@ -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 ###

38
scintilla/cocoa/SciTest.mk
View File

@ -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)

8
scintilla/cocoa/ScintillaCocoa.h
View File

@ -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();

67
scintilla/cocoa/ScintillaCocoa.mm
View File

@ -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();
}
//--------------------------------------------------------------------------------------------------

BIN
scintilla/cocoa/ScintillaFramework/English.lproj/InfoPlist.strings
View File

Binary file not shown.

1162
scintilla/cocoa/ScintillaFramework/ScintillaFramework.xcodeproj/project.pbxproj
View File

File diff suppressed because it is too large Load Diff

1
scintilla/cocoa/ScintillaTest/AppController.h
View File

@ -19,5 +19,6 @@
- (void) awakeFromNib;
- (void) setupEditor;
- (IBAction) searchText: (id) sender;
@end

12
scintilla/cocoa/ScintillaTest/AppController.mm
View File

@ -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
//--------------------------------------------------------------------------------------------------

BIN
scintilla/cocoa/ScintillaTest/English.lproj/InfoPlist.strings
View File

Binary file not shown.

927
scintilla/cocoa/ScintillaTest/English.lproj/MainMenu.xib
View File

File diff suppressed because it is too large Load Diff

16
scintilla/cocoa/ScintillaView.h
View File

@ -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

88
scintilla/cocoa/ScintillaView.mm
View File

@ -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

57
scintilla/cocoa/common.mk Normal file
View File

@ -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 $@

3
scintilla/doc/Design.html
View File

@ -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>
</body>
</html>

3
scintilla/doc/Icons.html
View File

@ -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>
</body>
</html>

3
scintilla/doc/SciCoding.html
View File

@ -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>
</body>
</html>

393
scintilla/doc/ScintillaDoc.html
View File

@ -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>
</body>
</html>

13
scintilla/doc/ScintillaDownload.html
View File

@ -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>
</body>
</html>

132
scintilla/doc/ScintillaHistory.html
View File

@ -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>
@ -1297,7 +1420,7 @@
The horizontal scroll bar may grow to match the widest line displayed.
</li>
<li>
Allow autocomplete popups to appear outside client rectangle in some cases.
Allow autocomplete pop ups to appear outside client rectangle in some cases.
</li>
<li>
When line state changed, SC_MOD_CHANGELINESTATE modification notification sent and
@ -2402,7 +2525,7 @@
Released on 4 April 2005.
</li>
<li>
Autocompletion on Windows changed to use popup window, be faster,
Autocompletion on Windows changed to use pop up window, be faster,
allow choice of maximum width and height, and to highlight only the text of the
selected item rather than both the text and icon if any.
</li>
@ -5417,7 +5540,7 @@
C++ lexer can fold comments of /* .. */ form.
</li>
<li>
Better disabling of popup menu items in Scintilla when in read-only mode.
Better disabling of pop up menu items in Scintilla when in read-only mode.
</li>
<li>
Starting to move to Doxygen compatible commenting.
@ -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>
</body>
</html>

3
scintilla/doc/ScintillaRelated.html
View File

@ -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>
</body>
</html>

3
scintilla/doc/ScintillaToDo.html
View File

@ -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>
</body>
</html>

3
scintilla/doc/ScintillaUsage.html
View File

@ -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>
</body>
</html>

1
scintilla/doc/Steps.html
View File

@ -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>

15
scintilla/doc/index.html
View File

@ -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>
</body>
</html>

3
scintilla/gtk/PlatGTK.cxx
View File

@ -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.

14
scintilla/gtk/ScintillaGTK.cxx
View File

@ -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;

319
scintilla/gtk/deps.mak
View File

@ -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

31
scintilla/gtk/makefile
View File

@ -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)

79
scintilla/include/Accessor.h
View File

@ -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;
};

67
scintilla/include/ILexer.h Normal file
View File

@ -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

113
scintilla/include/KeyWords.h
View File

@ -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;
}

26
scintilla/include/PropSet.h
View File

@ -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

30
scintilla/include/SciLexer.h
View File

@ -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

17
scintilla/include/Scintilla.h
View File

@ -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

68
scintilla/include/Scintilla.iface
View File

@ -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

67
scintilla/include/WindowAccessor.h
View File

@ -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

18
scintilla/src/LexAPDL.cxx → scintilla/lexers/LexAPDL.cxx
View File

@ -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

16
scintilla/src/LexASY.cxx → scintilla/lexers/LexASY.cxx
View File

@ -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;

18
scintilla/src/LexAU3.cxx → scintilla/lexers/LexAU3.cxx
View File

@ -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

20
scintilla/src/LexAVE.cxx → scintilla/lexers/LexAVE.cxx
View File

@ -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

18
scintilla/src/LexAbaqus.cxx → scintilla/lexers/LexAbaqus.cxx
View File

@ -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

15
scintilla/src/LexAda.cxx → scintilla/lexers/LexAda.cxx
View File

@ -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;

18
scintilla/src/LexAsm.cxx → scintilla/lexers/LexAsm.cxx
View File

@ -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

18
scintilla/src/LexAsn1.cxx → scintilla/lexers/LexAsn1.cxx
View File

@ -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

18
scintilla/src/LexBaan.cxx → scintilla/lexers/LexBaan.cxx
View File

@ -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

220
scintilla/src/LexBash.cxx → scintilla/lexers/LexBash.cxx
View File

@ -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();
}

17
scintilla/src/LexBasic.cxx → scintilla/lexers/LexBasic.cxx
View File

@ -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

17
scintilla/src/LexBullant.cxx → scintilla/lexers/LexBullant.cxx
View File

@ -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

16
scintilla/src/LexCLW.cxx → scintilla/lexers/LexCLW.cxx
View File

@ -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

20
scintilla/src/LexCOBOL.cxx → scintilla/lexers/LexCOBOL.cxx
View File

@ -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;
}

1043
scintilla/lexers/LexCPP.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

18
scintilla/src/LexCSS.cxx → scintilla/lexers/LexCSS.cxx
View File

@ -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

23
scintilla/src/LexCaml.cxx → scintilla/lexers/LexCaml.cxx
View File

@ -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

19
scintilla/src/LexCmake.cxx → scintilla/lexers/LexCmake.cxx
View File

@ -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

17
scintilla/src/LexConf.cxx → scintilla/lexers/LexConf.cxx
View File

@ -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

17
scintilla/src/LexCrontab.cxx → scintilla/lexers/LexCrontab.cxx
View File

@ -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

17
scintilla/src/LexCsound.cxx → scintilla/lexers/LexCsound.cxx
View File

@ -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

18
scintilla/src/LexD.cxx → scintilla/lexers/LexD.cxx
View File

@ -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

16
scintilla/src/LexEScript.cxx → scintilla/lexers/LexEScript.cxx
View File

@ -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

20
scintilla/src/LexEiffel.cxx → scintilla/lexers/LexEiffel.cxx
View File

@ -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

17
scintilla/src/LexErlang.cxx → scintilla/lexers/LexErlang.cxx
View File

@ -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

17
scintilla/src/LexFlagship.cxx → scintilla/lexers/LexFlagship.cxx
View File

@ -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;

18
scintilla/src/LexForth.cxx → scintilla/lexers/LexForth.cxx
View File

@ -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

18
scintilla/src/LexFortran.cxx → scintilla/lexers/LexFortran.cxx
View File

@ -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

18
scintilla/src/LexGAP.cxx → scintilla/lexers/LexGAP.cxx
View File

@ -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

18
scintilla/src/LexGui4Cli.cxx → scintilla/lexers/LexGui4Cli.cxx
View File

@ -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

25
scintilla/src/LexHTML.cxx → scintilla/lexers/LexHTML.cxx
View File

@ -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) ) {

19
scintilla/src/LexHaskell.cxx → scintilla/lexers/LexHaskell.cxx
View File

@ -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

19
scintilla/src/LexInno.cxx → scintilla/lexers/LexInno.cxx
View File

@ -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

18
scintilla/src/LexKix.cxx → scintilla/lexers/LexKix.cxx
View File

@ -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

18
scintilla/src/LexLisp.cxx → scintilla/lexers/LexLisp.cxx
View File

@ -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;

18
scintilla/src/LexLout.cxx → scintilla/lexers/LexLout.cxx
View File

@ -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

19
scintilla/src/LexLua.cxx → scintilla/lexers/LexLua.cxx
View File

@ -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;

18
scintilla/src/LexMMIXAL.cxx → scintilla/lexers/LexMMIXAL.cxx
View File

@ -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

19
scintilla/src/LexMPT.cxx → scintilla/lexers/LexMPT.cxx
View File

@ -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

17
scintilla/src/LexMSSQL.cxx → scintilla/lexers/LexMSSQL.cxx
View File

@ -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

18
scintilla/src/LexMagik.cxx → scintilla/lexers/LexMagik.cxx
View File

@ -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

17
scintilla/src/LexMarkdown.cxx → scintilla/lexers/LexMarkdown.cxx
View File

@ -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

18
scintilla/src/LexMatlab.cxx → scintilla/lexers/LexMatlab.cxx
View File

@ -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

16
scintilla/src/LexMetapost.cxx → scintilla/lexers/LexMetapost.cxx
View File

@ -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;

18
scintilla/src/LexMySQL.cxx → scintilla/lexers/LexMySQL.cxx
View File

@ -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

20
scintilla/src/LexNimrod.cxx → scintilla/lexers/LexNimrod.cxx
View File

@ -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

19
scintilla/src/LexNsis.cxx → scintilla/lexers/LexNsis.cxx
View File

@ -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

0
scintilla/src/LexObjC.cxx → scintilla/lexers/LexObjC.cxx
View File

16
scintilla/src/LexOpal.cxx → scintilla/lexers/LexOpal.cxx
View File

@ -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;

18
scintilla/src/LexOthers.cxx → scintilla/lexers/LexOthers.cxx
View File

@ -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

18
scintilla/src/LexPB.cxx → scintilla/lexers/LexPB.cxx
View File

@ -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

16
scintilla/src/LexPLM.cxx → scintilla/lexers/LexPLM.cxx
View File

@ -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;

18
scintilla/src/LexPOV.cxx → scintilla/lexers/LexPOV.cxx
View File

@ -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

20
scintilla/src/LexPS.cxx → scintilla/lexers/LexPS.cxx
View File

@ -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

15
scintilla/src/LexPascal.cxx → scintilla/lexers/LexPascal.cxx
View File

@ -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;

74
scintilla/src/LexPerl.cxx → scintilla/lexers/LexPerl.cxx
View File

@ -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);
@ -1222,52 +1245,61 @@ static void FoldPerlDoc(unsigned int startPos, int length, int, WordList *[],
&& IsCommentLine(lineCurrent + 1, styler))
levelCurrent++;
else if (IsCommentLine(lineCurrent - 1, styler)
&& !IsCommentLine(lineCurrent+1, styler))
&& !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

20
scintilla/src/LexPowerPro.cxx → scintilla/lexers/LexPowerPro.cxx
View File

@ -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;

45
scintilla/src/LexPowerShell.cxx → scintilla/lexers/LexPowerShell.cxx
View File

@ -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
};

18
scintilla/src/LexProgress.cxx → scintilla/lexers/LexProgress.cxx
View File

@ -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

20
scintilla/src/LexPython.cxx → scintilla/lexers/LexPython.cxx
View File

@ -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

18
scintilla/src/LexR.cxx → scintilla/lexers/LexR.cxx
View File

@ -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

16
scintilla/src/LexRebol.cxx → scintilla/lexers/LexRebol.cxx
View File

@ -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;

17
scintilla/src/LexRuby.cxx → scintilla/lexers/LexRuby.cxx
View File

@ -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

19
scintilla/src/LexSML.cxx → scintilla/lexers/LexSML.cxx
View File

@ -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 == '_';}

Some files were not shown because too many files have changed in this diff Show More