Use Sci_Position when required to implement interfaces.

22 files changed, 160 insertions, 160 deletions

diff --git a/lexers/LexAsm.cxx b/lexers/LexAsm.cxx
index 37a4efe35..ded7a4348 100644
--- a/lexers/LexAsm.cxx
+++ b/lexers/LexAsm.cxx
@@ -172,13 +172,13 @@ public:
 	const char * SCI_METHOD DescribeProperty(const char *name) {
 		return osAsm.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets() {
 		return osAsm.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -193,14 +193,14 @@ public:
 	}
 };
 
-int SCI_METHOD LexerAsm::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerAsm::PropertySet(const char *key, const char *val) {
 	if (osAsm.PropertySet(&options, key, val)) {
 		return 0;
 	}
 	return -1;
 }
 
-int SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -240,7 +240,7 @@ int SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) {
 	return firstModification;
 }
 
-void SCI_METHOD LexerAsm::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	LexAccessor styler(pAccess);
 
 	// Do not leak onto next line
@@ -371,7 +371,7 @@ void SCI_METHOD LexerAsm::Lex(unsigned int startPos, int length, int initStyle,
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "else".
 
-void SCI_METHOD LexerAsm::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
diff --git a/lexers/LexBasic.cxx b/lexers/LexBasic.cxx
index b73fac8b6..94d350b42 100644
--- a/lexers/LexBasic.cxx
+++ b/lexers/LexBasic.cxx
@@ -255,13 +255,13 @@ public:
 	const char * SCI_METHOD DescribeProperty(const char *name) {
 		return osBasic.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets() {
 		return osBasic.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -277,14 +277,14 @@ public:
 	}
 };
 
-int SCI_METHOD LexerBasic::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerBasic::PropertySet(const char *key, const char *val) {
 	if (osBasic.PropertySet(&options, key, val)) {
 		return 0;
 	}
 	return -1;
 }
 
-int SCI_METHOD LexerBasic::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerBasic::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -312,7 +312,7 @@ int SCI_METHOD LexerBasic::WordListSet(int n, const char *wl) {
 	return firstModification;
 }
 
-void SCI_METHOD LexerBasic::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerBasic::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	LexAccessor styler(pAccess);
 
 	bool wasfirst = true, isfirst = true; // true if first token in a line
@@ -471,7 +471,7 @@ void SCI_METHOD LexerBasic::Lex(unsigned int startPos, int length, int initStyle
 }
 
 
-void SCI_METHOD LexerBasic::Fold(unsigned int startPos, int length, int /* initStyle */, IDocument *pAccess) {
+void SCI_METHOD LexerBasic::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
diff --git a/lexers/LexCPP.cxx b/lexers/LexCPP.cxx
index 1d9e40d17..da558b357 100644
--- a/lexers/LexCPP.cxx
+++ b/lexers/LexCPP.cxx
@@ -495,13 +495,13 @@ public:
 	const char * SCI_METHOD DescribeProperty(const char *name) {
 		return osCPP.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets() {
 		return osCPP.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -555,7 +555,7 @@ public:
 	bool EvaluateExpression(const std::string &expr, const SymbolTable &preprocessorDefinitions);
 };
 
-int SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val) {
 	if (osCPP.PropertySet(&options, key, val)) {
 		if (strcmp(key, "lexer.cpp.allow.dollars") == 0) {
 			setWord = CharacterSet(CharacterSet::setAlphaNum, "._", 0x80, true);
@@ -568,7 +568,7 @@ int SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val) {
 	return -1;
 }
 
-int SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -637,7 +637,7 @@ struct After {
 	}
 };
 
-void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	LexAccessor styler(pAccess);
 
 	CharacterSet setOKBeforeRE(CharacterSet::setNone, "([{=,:;!%^&*|?~+-");
@@ -1279,7 +1279,7 @@ void SCI_METHOD LexerCPP::Lex(unsigned int startPos, int length, int initStyle,
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
 
-void SCI_METHOD LexerCPP::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerCPP::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
diff --git a/lexers/LexD.cxx b/lexers/LexD.cxx
index 045c4cb73..4d699da61 100644
--- a/lexers/LexD.cxx
+++ b/lexers/LexD.cxx
@@ -177,13 +177,13 @@ public:
 	const char * SCI_METHOD DescribeProperty(const char *name) {
 		return osD.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets() {
 		return osD.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -197,14 +197,14 @@ public:
 	}
 };
 
-int SCI_METHOD LexerD::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerD::PropertySet(const char *key, const char *val) {
 	if (osD.PropertySet(&options, key, val)) {
 		return 0;
 	}
 	return -1;
 }
 
-int SCI_METHOD LexerD::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerD::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -241,7 +241,7 @@ int SCI_METHOD LexerD::WordListSet(int n, const char *wl) {
 	return firstModification;
 }
 
-void SCI_METHOD LexerD::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerD::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	LexAccessor styler(pAccess);
 
 	int styleBeforeDCKeyword = SCE_D_DEFAULT;
@@ -471,7 +471,7 @@ void SCI_METHOD LexerD::Lex(unsigned int startPos, int length, int initStyle, ID
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
 
-void SCI_METHOD LexerD::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerD::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
diff --git a/lexers/LexDMIS.cxx b/lexers/LexDMIS.cxx
index a903e9da6..39d40b6cc 100644
--- a/lexers/LexDMIS.cxx
+++ b/lexers/LexDMIS.cxx
@@ -76,11 +76,11 @@ class LexerDMIS : public ILexer
 			return NULL;
 		}
 
-		int SCI_METHOD PropertySet(const char *, const char *) {
+		Sci_Position SCI_METHOD PropertySet(const char *, const char *) {
 			return -1;
 		}
 
-		int SCI_METHOD WordListSet(int n, const char *wl);
+		Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
 
 		void * SCI_METHOD PrivateCall(int, void *) {
 			return NULL;
@@ -91,8 +91,8 @@ class LexerDMIS : public ILexer
 		}
 
 		const char * SCI_METHOD DescribeWordListSets();
-		void SCI_METHOD Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
-		void SCI_METHOD Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
+		void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
+		void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
 };
 
 
@@ -145,7 +145,7 @@ LexerDMIS::~LexerDMIS(void) {
 	delete[] this->m_wordListSets;
 }
 
-int SCI_METHOD LexerDMIS::WordListSet(int n, const char *wl)
+Sci_Position SCI_METHOD LexerDMIS::WordListSet(int n, const char *wl)
 {
 	switch (n) {
 		case 0:
@@ -185,7 +185,7 @@ const char * SCI_METHOD LexerDMIS::DescribeWordListSets()
 	return this->m_wordListSets;
 }
 
-void SCI_METHOD LexerDMIS::Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess)
+void SCI_METHOD LexerDMIS::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess)
 {
 	const unsigned int MAX_STR_LEN = 100;
 
@@ -281,7 +281,7 @@ void SCI_METHOD LexerDMIS::Lex(unsigned int startPos, int lengthDoc, int initSty
 	scCTX.Complete();
 }
 
-void SCI_METHOD LexerDMIS::Fold(unsigned int startPos, int lengthDoc, int, IDocument *pAccess)
+void SCI_METHOD LexerDMIS::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int, IDocument *pAccess)
 {
 	const int MAX_STR_LEN = 100;
 
diff --git a/lexers/LexHaskell.cxx b/lexers/LexHaskell.cxx
index 24355fa4e..18ac15db9 100644
--- a/lexers/LexHaskell.cxx
+++ b/lexers/LexHaskell.cxx
@@ -416,17 +416,17 @@ public:
       return osHaskell.DescribeProperty(name);
    }
 
-   int SCI_METHOD PropertySet(const char *key, const char *val);
+   Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 
    const char * SCI_METHOD DescribeWordListSets() {
       return osHaskell.DescribeWordListSets();
    }
 
-   int SCI_METHOD WordListSet(int n, const char *wl);
+   Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
 
-   void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+   void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
-   void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+   void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
    void * SCI_METHOD PrivateCall(int, void *) {
       return 0;
@@ -441,14 +441,14 @@ public:
    }
 };
 
-int SCI_METHOD LexerHaskell::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerHaskell::PropertySet(const char *key, const char *val) {
    if (osHaskell.PropertySet(&options, key, val)) {
       return 0;
    }
    return -1;
 }
 
-int SCI_METHOD LexerHaskell::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerHaskell::WordListSet(int n, const char *wl) {
    WordList *wordListN = 0;
    switch (n) {
    case 0:
@@ -473,7 +473,7 @@ int SCI_METHOD LexerHaskell::WordListSet(int n, const char *wl) {
    return firstModification;
 }
 
-void SCI_METHOD LexerHaskell::Lex(unsigned int startPos, int length, int initStyle
+void SCI_METHOD LexerHaskell::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle
                                  ,IDocument *pAccess) {
    LexAccessor styler(pAccess);
 
@@ -961,7 +961,7 @@ void SCI_METHOD LexerHaskell::Lex(unsigned int startPos, int length, int initSty
    sc.Complete();
 }
 
-void SCI_METHOD LexerHaskell::Fold(unsigned int startPos, int length, int // initStyle
+void SCI_METHOD LexerHaskell::Fold(Sci_PositionU startPos, Sci_Position length, int // initStyle
                                   ,IDocument *pAccess) {
    if (!options.fold)
       return;
diff --git a/lexers/LexLaTeX.cxx b/lexers/LexLaTeX.cxx
index f8af1e7dc..d2ab191fa 100644
--- a/lexers/LexLaTeX.cxx
+++ b/lexers/LexLaTeX.cxx
@@ -81,8 +81,8 @@ public:
 	static ILexer *LexerFactoryLaTeX() {
 		return new LexerLaTeX();
 	}
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 };
 
 static bool latexIsSpecial(int ch) {
@@ -184,7 +184,7 @@ static inline void latexStateReset(int &mode, int &state) {
 
 // There are cases not handled correctly, like $abcd\textrm{what is $x+y$}z+w$.
 // But I think it's already good enough.
-void SCI_METHOD LexerLaTeX::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerLaTeX::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	// startPos is assumed to be the first character of a line
 	Accessor styler(pAccess, &props);
 	styler.StartAt(startPos);
@@ -470,7 +470,7 @@ static int latexFoldSaveToInt(const latexFoldSave &save) {
 
 // Change folding state while processing a line
 // Return the level before the first relevant command
-void SCI_METHOD LexerLaTeX::Fold(unsigned int startPos, int length, int, IDocument *pAccess) {
+void SCI_METHOD LexerLaTeX::Fold(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess) {
 	const char *structWords[7] = {"part", "chapter", "section", "subsection",
 		"subsubsection", "paragraph", "subparagraph"};
 	Accessor styler(pAccess, &props);
diff --git a/lexers/LexPerl.cxx b/lexers/LexPerl.cxx
index b4a2dd12e..c81dc2663 100644
--- a/lexers/LexPerl.cxx
+++ b/lexers/LexPerl.cxx
@@ -367,13 +367,13 @@ public:
 	const char *SCI_METHOD DescribeProperty(const char *name) {
 		return osPerl.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char *SCI_METHOD DescribeWordListSets() {
 		return osPerl.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
 	void *SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -386,14 +386,14 @@ public:
 	void InterpolateSegment(StyleContext &sc, int maxSeg, bool isPattern=false);
 };
 
-int SCI_METHOD LexerPerl::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerPerl::PropertySet(const char *key, const char *val) {
 	if (osPerl.PropertySet(&options, key, val)) {
 		return 0;
 	}
 	return -1;
 }
 
-int SCI_METHOD LexerPerl::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerPerl::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -515,7 +515,7 @@ void LexerPerl::InterpolateSegment(StyleContext &sc, int maxSeg, bool isPattern)
 		sc.SetState(sc.state - INTERPOLATE_SHIFT);
 }
 
-void SCI_METHOD LexerPerl::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerPerl::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	LexAccessor styler(pAccess);
 
 	// keywords that forces /PATTERN/ at all times; should track vim's behaviour
@@ -1557,7 +1557,7 @@ void SCI_METHOD LexerPerl::Lex(unsigned int startPos, int length, int initStyle,
 #define PERL_HEADFOLD_SHIFT		4
 #define PERL_HEADFOLD_MASK		0xF0
 
-void SCI_METHOD LexerPerl::Fold(unsigned int startPos, int length, int /* initStyle */, IDocument *pAccess) {
+void SCI_METHOD LexerPerl::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
diff --git a/lexers/LexPython.cxx b/lexers/LexPython.cxx
index 76e1530f1..c12810c03 100644
--- a/lexers/LexPython.cxx
+++ b/lexers/LexPython.cxx
@@ -225,13 +225,13 @@ public:
 	const char * SCI_METHOD DescribeProperty(const char *name) {
 		return osPython.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets() {
 		return osPython.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -275,14 +275,14 @@ public:
 	}
 };
 
-int SCI_METHOD LexerPython::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerPython::PropertySet(const char *key, const char *val) {
 	if (osPython.PropertySet(&options, key, val)) {
 		return 0;
 	}
 	return -1;
 }
 
-int SCI_METHOD LexerPython::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerPython::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -304,7 +304,7 @@ int SCI_METHOD LexerPython::WordListSet(int n, const char *wl) {
 	return firstModification;
 }
 
-void SCI_METHOD LexerPython::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerPython::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	Accessor styler(pAccess, NULL);
 
 	const int endPos = startPos + length;
@@ -595,7 +595,7 @@ static bool IsQuoteLine(int line, Accessor &styler) {
 }
 
 
-void SCI_METHOD LexerPython::Fold(unsigned int startPos, int length, int /*initStyle - unused*/, IDocument *pAccess) {
+void SCI_METHOD LexerPython::Fold(Sci_PositionU startPos, Sci_Position length, int /*initStyle - unused*/, IDocument *pAccess) {
 	if (!options.fold)
 		return;
 
diff --git a/lexers/LexRegistry.cxx b/lexers/LexRegistry.cxx
index 0f401fa4b..22fdd111e 100644
--- a/lexers/LexRegistry.cxx
+++ b/lexers/LexRegistry.cxx
@@ -179,13 +179,13 @@ public:
 	virtual const char *SCI_METHOD DescribeProperty(const char *name) {
 		return optSetRegistry.DescribeProperty(name);
 	}
-	virtual int SCI_METHOD PropertySet(const char *key, const char *val) {
+	virtual Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) {
 		if (optSetRegistry.PropertySet(&options, key, val)) {
 			return 0;
 		}
 		return -1;
 	}
-	virtual int SCI_METHOD WordListSet(int, const char *) {
+	virtual Sci_Position SCI_METHOD WordListSet(int, const char *) {
 		return -1;
 	}
 	virtual void *SCI_METHOD PrivateCall(int, void *) {
@@ -197,18 +197,18 @@ public:
 	virtual const char *SCI_METHOD DescribeWordListSets() {
 		return optSetRegistry.DescribeWordListSets();
 	}
-	virtual void SCI_METHOD Lex(unsigned startPos,
-								int length,
+	virtual void SCI_METHOD Lex(Sci_PositionU startPos,
+								Sci_Position length,
 								int initStyle,
 								IDocument *pAccess);
-	virtual void SCI_METHOD Fold(unsigned startPos,
-								 int length,
+	virtual void SCI_METHOD Fold(Sci_PositionU startPos,
+								 Sci_Position length,
 								 int initStyle,
 								 IDocument *pAccess);
 };
 
-void SCI_METHOD LexerRegistry::Lex(unsigned startPos,
-								   int length,
+void SCI_METHOD LexerRegistry::Lex(Sci_PositionU startPos,
+								   Sci_Position length,
 								   int initStyle,
 								   IDocument *pAccess) {
 	int beforeGUID = SCE_REG_DEFAULT;
@@ -352,8 +352,8 @@ void SCI_METHOD LexerRegistry::Lex(unsigned startPos,
 }
 
 // Folding similar to that of FoldPropsDoc in LexOthers
-void SCI_METHOD LexerRegistry::Fold(unsigned startPos,
-									int length,
+void SCI_METHOD LexerRegistry::Fold(Sci_PositionU startPos,
+									Sci_Position length,
 									int,
 									IDocument *pAccess) {
 	if (!options.fold) {
diff --git a/lexers/LexRust.cxx b/lexers/LexRust.cxx
index 80ec014ca..398b6bf32 100644
--- a/lexers/LexRust.cxx
+++ b/lexers/LexRust.cxx
@@ -138,13 +138,13 @@ public:
 	const char * SCI_METHOD DescribeProperty(const char *name) {
 		return osRust.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets() {
 		return osRust.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
 	}
@@ -153,14 +153,14 @@ public:
 	}
 };
 
-int SCI_METHOD LexerRust::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerRust::PropertySet(const char *key, const char *val) {
 	if (osRust.PropertySet(&options, key, val)) {
 		return 0;
 	}
 	return -1;
 }
 
-int SCI_METHOD LexerRust::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerRust::WordListSet(int n, const char *wl) {
 	int firstModification = -1;
 	if (n < NUM_RUST_KEYWORD_LISTS) {
 		WordList *wordListN = &keywords[n];
@@ -643,7 +643,7 @@ static void ScanRawString(Accessor &styler, int& pos, int max, bool ascii_only)
 	}
 }
 
-void SCI_METHOD LexerRust::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerRust::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	PropSetSimple props;
 	Accessor styler(pAccess, &props);
 	int pos = startPos;
@@ -716,7 +716,7 @@ void SCI_METHOD LexerRust::Lex(unsigned int startPos, int length, int initStyle,
 	styler.Flush();
 }
 
-void SCI_METHOD LexerRust::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerRust::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 
 	if (!options.fold)
 		return;
diff --git a/lexers/LexSQL.cxx b/lexers/LexSQL.cxx
index 176c92c32..82236e55f 100644
--- a/lexers/LexSQL.cxx
+++ b/lexers/LexSQL.cxx
@@ -328,7 +328,7 @@ public :
 		return osSQL.DescribeProperty(name);
 	}
 
-	int SCI_METHOD PropertySet(const char *key, const char *val) {
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) {
 		if (osSQL.PropertySet(&options, key, val)) {
 			return 0;
 		}
@@ -339,9 +339,9 @@ public :
 		return osSQL.DescribeWordListSets();
 	}
 
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex (unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
 
 	void * SCI_METHOD PrivateCall(int, void *) {
 		return 0;
@@ -400,7 +400,7 @@ private:
 	WordList kw_user4;
 };
 
-int SCI_METHOD LexerSQL::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerSQL::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -439,7 +439,7 @@ int SCI_METHOD LexerSQL::WordListSet(int n, const char *wl) {
 	return firstModification;
 }
 
-void SCI_METHOD LexerSQL::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerSQL::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	LexAccessor styler(pAccess);
 	StyleContext sc(startPos, length, initStyle, styler);
 	int styleBeforeDCKeyword = SCE_SQL_DEFAULT;
@@ -628,7 +628,7 @@ void SCI_METHOD LexerSQL::Lex(unsigned int startPos, int length, int initStyle,
 	sc.Complete();
 }
 
-void SCI_METHOD LexerSQL::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerSQL::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	if (!options.fold)
 		return;
 	LexAccessor styler(pAccess);
diff --git a/lexers/LexVerilog.cxx b/lexers/LexVerilog.cxx
index 55dfa06c7..cee736492 100644
--- a/lexers/LexVerilog.cxx
+++ b/lexers/LexVerilog.cxx
@@ -232,15 +232,15 @@ public:
 	const char* SCI_METHOD DescribeProperty(const char* name) {
 		return osVerilog.DescribeProperty(name);
 	}
-	int SCI_METHOD PropertySet(const char* key, const char* val) {
+	Sci_Position SCI_METHOD PropertySet(const char* key, const char* val) {
 	    return osVerilog.PropertySet(&options, key, val);
 	}
 	const char* SCI_METHOD DescribeWordListSets() {
 		return osVerilog.DescribeWordListSets();
 	}
-	int SCI_METHOD WordListSet(int n, const char* wl);
-	void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char* wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 	void* SCI_METHOD PrivateCall(int, void*) {
 		return 0;
 	}
@@ -285,7 +285,7 @@ public:
 	std::vector<std::string> Tokenize(const std::string &expr) const;
 };
 
-int SCI_METHOD LexerVerilog::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerVerilog::WordListSet(int n, const char *wl) {
 	WordList *wordListN = 0;
 	switch (n) {
 	case 0:
@@ -391,7 +391,7 @@ static bool IsSpaceOrTab(int ch) {
 	return ch == ' ' || ch == '\t';
 }
 
-void SCI_METHOD LexerVerilog::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess)
+void SCI_METHOD LexerVerilog::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess)
 {
 	LexAccessor styler(pAccess);
 
@@ -784,7 +784,7 @@ static bool IsCommentLine(int line, LexAccessor &styler) {
 // 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 {".
-void SCI_METHOD LexerVerilog::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess)
+void SCI_METHOD LexerVerilog::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess)
 {
 	LexAccessor styler(pAccess);
 	bool foldAtBrace  = 1;
diff --git a/lexers/LexVisualProlog.cxx b/lexers/LexVisualProlog.cxx
index 24e19e24e..7d6851872 100644
--- a/lexers/LexVisualProlog.cxx
+++ b/lexers/LexVisualProlog.cxx
@@ -91,13 +91,13 @@ public:
     const char * SCI_METHOD DescribeProperty(const char *name) {
         return osVisualProlog.DescribeProperty(name);
     }
-    int SCI_METHOD PropertySet(const char *key, const char *val);
+    Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
     const char * SCI_METHOD DescribeWordListSets() {
         return osVisualProlog.DescribeWordListSets();
     }
-    int SCI_METHOD WordListSet(int n, const char *wl);
-    void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
-    void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);
+    Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+    void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+    void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
 
     void * SCI_METHOD PrivateCall(int, void *) {
         return 0;
@@ -108,14 +108,14 @@ public:
     }
 };
 
-int SCI_METHOD LexerVisualProlog::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerVisualProlog::PropertySet(const char *key, const char *val) {
     if (osVisualProlog.PropertySet(&options, key, val)) {
         return 0;
     }
     return -1;
 }
 
-int SCI_METHOD LexerVisualProlog::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerVisualProlog::WordListSet(int n, const char *wl) {
     WordList *wordListN = 0;
     switch (n) {
     case 0:
@@ -244,7 +244,7 @@ static void forwardEscapeLiteral(StyleContext &sc, int EscapeState) {
     }
 }
 
-void SCI_METHOD LexerVisualProlog::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerVisualProlog::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
     LexAccessor styler(pAccess);
     CharacterSet setDoxygen(CharacterSet::setAlpha, "");
     CharacterSet setNumber(CharacterSet::setNone, "+-.0123456789abcdefABCDEFxoXO");
@@ -446,7 +446,7 @@ void SCI_METHOD LexerVisualProlog::Lex(unsigned int startPos, int length, int in
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
 
-void SCI_METHOD LexerVisualProlog::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerVisualProlog::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 
     LexAccessor styler(pAccess);
 
diff --git a/lexlib/LexerBase.cxx b/lexlib/LexerBase.cxx
index bbef3f159..d887b3c6c 100644
--- a/lexlib/LexerBase.cxx
+++ b/lexlib/LexerBase.cxx
@@ -61,7 +61,7 @@ const char * SCI_METHOD LexerBase::DescribeProperty(const char *) {
 	return "";
 }
 
-int SCI_METHOD LexerBase::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerBase::PropertySet(const char *key, const char *val) {
 	const char *valOld = props.Get(key);
 	if (strcmp(val, valOld) != 0) {
 		props.Set(key, val);
@@ -75,7 +75,7 @@ const char * SCI_METHOD LexerBase::DescribeWordListSets() {
 	return "";
 }
 
-int SCI_METHOD LexerBase::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerBase::WordListSet(int n, const char *wl) {
 	if (n < numWordLists) {
 		WordList wlNew;
 		wlNew.Set(wl);
diff --git a/lexlib/LexerBase.h b/lexlib/LexerBase.h
index 2998d2449..d8849d2f9 100644
--- a/lexlib/LexerBase.h
+++ b/lexlib/LexerBase.h
@@ -26,11 +26,11 @@ public:
 	const char * SCI_METHOD PropertyNames();
 	int SCI_METHOD PropertyType(const char *name);
 	const char * SCI_METHOD DescribeProperty(const char *name);
-	int SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
 	const char * SCI_METHOD DescribeWordListSets();
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess) = 0;
-	void SCI_METHOD Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess) = 0;
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0;
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0;
 	void * SCI_METHOD PrivateCall(int operation, void *pointer);
 };
 
diff --git a/lexlib/LexerNoExceptions.cxx b/lexlib/LexerNoExceptions.cxx
index 9ebae2af0..30c291bcb 100644
--- a/lexlib/LexerNoExceptions.cxx
+++ b/lexlib/LexerNoExceptions.cxx
@@ -28,7 +28,7 @@
 using namespace Scintilla;
 #endif
 
-int SCI_METHOD LexerNoExceptions::PropertySet(const char *key, const char *val) {
+Sci_Position SCI_METHOD LexerNoExceptions::PropertySet(const char *key, const char *val) {
 	try {
 		return LexerBase::PropertySet(key, val);
 	} catch (...) {
@@ -37,7 +37,7 @@ int SCI_METHOD LexerNoExceptions::PropertySet(const char *key, const char *val)
 	return -1;
 }
 
-int SCI_METHOD LexerNoExceptions::WordListSet(int n, const char *wl) {
+Sci_Position SCI_METHOD LexerNoExceptions::WordListSet(int n, const char *wl) {
 	try {
 		return LexerBase::WordListSet(n, wl);
 	} catch (...) {
@@ -46,7 +46,7 @@ int SCI_METHOD LexerNoExceptions::WordListSet(int n, const char *wl) {
 	return -1;
 }
 
-void SCI_METHOD LexerNoExceptions::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerNoExceptions::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	try {
 		Accessor astyler(pAccess, &props);
 		Lexer(startPos, length, initStyle, pAccess, astyler);
@@ -56,7 +56,7 @@ void SCI_METHOD LexerNoExceptions::Lex(unsigned int startPos, int length, int in
 		pAccess->SetErrorStatus(SC_STATUS_FAILURE);
 	}
 }
-void SCI_METHOD LexerNoExceptions::Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerNoExceptions::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
 	try {
 		Accessor astyler(pAccess, &props);
 		Folder(startPos, length, initStyle, pAccess, astyler);
diff --git a/lexlib/LexerNoExceptions.h b/lexlib/LexerNoExceptions.h
index 70ff3c138..2a846884e 100644
--- a/lexlib/LexerNoExceptions.h
+++ b/lexlib/LexerNoExceptions.h
@@ -16,10 +16,10 @@ namespace Scintilla {
 class LexerNoExceptions : public LexerBase {
 public:
 	// TODO Also need to prevent exceptions in constructor and destructor
-	int SCI_METHOD PropertySet(const char *key, const char *val);
-	int SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *);
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *);
 
 	virtual void Lexer(unsigned int startPos, int length, int initStyle, IDocument *pAccess, Accessor &styler) = 0;
 	virtual void Folder(unsigned int startPos, int length, int initStyle, IDocument *pAccess, Accessor &styler) = 0;
diff --git a/lexlib/LexerSimple.cxx b/lexlib/LexerSimple.cxx
index 4d0e178ca..437c96f78 100644
--- a/lexlib/LexerSimple.cxx
+++ b/lexlib/LexerSimple.cxx
@@ -42,13 +42,13 @@ const char * SCI_METHOD LexerSimple::DescribeWordListSets() {
 	return wordLists.c_str();
 }
 
-void SCI_METHOD LexerSimple::Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerSimple::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) {
 	Accessor astyler(pAccess, &props);
 	module->Lex(startPos, lengthDoc, initStyle, keyWordLists, astyler);
 	astyler.Flush();
 }
 
-void SCI_METHOD LexerSimple::Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess) {
+void SCI_METHOD LexerSimple::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) {
 	if (props.GetInt("fold")) {
 		Accessor astyler(pAccess, &props);
 		module->Fold(startPos, lengthDoc, initStyle, keyWordLists, astyler);
diff --git a/lexlib/LexerSimple.h b/lexlib/LexerSimple.h
index e9fa9003f..a88c409cb 100644
--- a/lexlib/LexerSimple.h
+++ b/lexlib/LexerSimple.h
@@ -19,8 +19,8 @@ class LexerSimple : public LexerBase {
 public:
 	explicit LexerSimple(const LexerModule *module_);
 	const char * SCI_METHOD DescribeWordListSets();
-	void SCI_METHOD Lex(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(unsigned int startPos, int lengthDoc, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess);
 };
 
 #ifdef SCI_NAMESPACE
diff --git a/src/Document.cxx b/src/Document.cxx
index 2eb412f73..f21477276 100644
--- a/src/Document.cxx
+++ b/src/Document.cxx
@@ -339,7 +339,7 @@ int Document::LineFromHandle(int markerHandle) {
 	return static_cast<LineMarkers *>(perLineData[ldMarkers])->LineFromHandle(markerHandle);
 }
 
-int SCI_METHOD Document::LineStart(int line) const {
+Sci_Position SCI_METHOD Document::LineStart(Sci_Position line) const {
 	return cb.LineStart(line);
 }
 
@@ -347,7 +347,7 @@ bool Document::IsLineStartPosition(int position) const {
 	return LineStart(LineFromPosition(position)) == position;
 }
 
-int SCI_METHOD Document::LineEnd(int line) const {
+Sci_Position SCI_METHOD Document::LineEnd(Sci_Position line) const {
 	if (line >= LinesTotal() - 1) {
 		return LineStart(line + 1);
 	} else {
@@ -381,7 +381,7 @@ void SCI_METHOD Document::SetErrorStatus(int status) {
 	}
 }
 
-int SCI_METHOD Document::LineFromPosition(int pos) const {
+Sci_Position SCI_METHOD Document::LineFromPosition(Sci_Position pos) const {
 	return cb.LineFromPosition(pos);
 }
 
@@ -410,7 +410,7 @@ int Document::VCHomePosition(int position) const {
 		return startText;
 }
 
-int SCI_METHOD Document::SetLevel(int line, int level) {
+int SCI_METHOD Document::SetLevel(Sci_Position line, int level) {
 	int prev = static_cast<LineLevels *>(perLineData[ldLevels])->SetLevel(line, level, LinesTotal());
 	if (prev != level) {
 		DocModification mh(SC_MOD_CHANGEFOLD | SC_MOD_CHANGEMARKER,
@@ -422,7 +422,7 @@ int SCI_METHOD Document::SetLevel(int line, int level) {
 	return prev;
 }
 
-int SCI_METHOD Document::GetLevel(int line) const {
+int SCI_METHOD Document::GetLevel(Sci_Position line) const {
 	return static_cast<LineLevels *>(perLineData[ldLevels])->GetLevel(line);
 }
 
@@ -770,7 +770,7 @@ bool Document::NextCharacter(int &pos, int moveDir) const {
 }
 
 // Return -1  on out-of-bounds
-int SCI_METHOD Document::GetRelativePosition(int positionStart, int characterOffset) const {
+Sci_Position SCI_METHOD Document::GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const {
 	int pos = positionStart;
 	if (dbcsCodePage) {
 		const int increment = (characterOffset > 0) ? 1 : -1;
@@ -810,7 +810,7 @@ int Document::GetRelativePositionUTF16(int positionStart, int characterOffset) c
 	return pos;
 }
 
-int SCI_METHOD Document::GetCharacterAndWidth(int position, int *pWidth) const {
+int SCI_METHOD Document::GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const {
 	int character;
 	int bytesInCharacter = 1;
 	if (dbcsCodePage) {
@@ -1050,7 +1050,7 @@ void Document::ChangeInsertion(const char *s, int length) {
 	insertion.assign(s, length);
 }
 
-int SCI_METHOD Document::AddData(char *data, int length) {
+int SCI_METHOD Document::AddData(char *data, Sci_Position length) {
 	try {
 		int position = Length();
 		InsertString(position, data, length);
@@ -1247,7 +1247,7 @@ static std::string CreateIndentation(int indent, int tabSize, bool insertSpaces)
 	return indentation;
 }
 
-int SCI_METHOD Document::GetLineIndentation(int line) {
+int SCI_METHOD Document::GetLineIndentation(Sci_Position line) {
 	int indent = 0;
 	if ((line >= 0) && (line < LinesTotal())) {
 		int lineStart = LineStart(line);
@@ -1827,11 +1827,11 @@ int Document::GetCharsOfClass(CharClassify::cc characterClass, unsigned char *bu
     return charClass.GetCharsOfClass(characterClass, buffer);
 }
 
-void SCI_METHOD Document::StartStyling(int position, char) {
+void SCI_METHOD Document::StartStyling(Sci_Position position, char) {
 	endStyled = position;
 }
 
-bool SCI_METHOD Document::SetStyleFor(int length, char style) {
+bool SCI_METHOD Document::SetStyleFor(Sci_Position length, char style) {
 	if (enteredStyling != 0) {
 		return false;
 	} else {
@@ -1848,7 +1848,7 @@ bool SCI_METHOD Document::SetStyleFor(int length, char style) {
 	}
 }
 
-bool SCI_METHOD Document::SetStyles(int length, const char *styles) {
+bool SCI_METHOD Document::SetStyles(Sci_Position length, const char *styles) {
 	if (enteredStyling != 0) {
 		return false;
 	} else {
@@ -1900,7 +1900,7 @@ void Document::LexerChanged() {
 	}
 }
 
-int SCI_METHOD Document::SetLineState(int line, int state) {
+int SCI_METHOD Document::SetLineState(Sci_Position line, int state) {
 	int statePrevious = static_cast<LineState *>(perLineData[ldState])->SetLineState(line, state);
 	if (state != statePrevious) {
 		DocModification mh(SC_MOD_CHANGELINESTATE, LineStart(line), 0, 0, 0, line);
@@ -1909,7 +1909,7 @@ int SCI_METHOD Document::SetLineState(int line, int state) {
 	return statePrevious;
 }
 
-int SCI_METHOD Document::GetLineState(int line) const {
+int SCI_METHOD Document::GetLineState(Sci_Position line) const {
 	return static_cast<LineState *>(perLineData[ldState])->GetLineState(line);
 }
 
@@ -1917,7 +1917,7 @@ int Document::GetMaxLineState() {
 	return static_cast<LineState *>(perLineData[ldState])->GetMaxLineState();
 }
 
-void SCI_METHOD Document::ChangeLexerState(int start, int end) {
+void SCI_METHOD Document::ChangeLexerState(Sci_Position start, Sci_Position end) {
 	DocModification mh(SC_MOD_LEXERSTATE, start, end-start, 0, 0, 0);
 	NotifyModified(mh);
 }
@@ -1997,7 +1997,7 @@ void Document::IncrementStyleClock() {
 	styleClock = (styleClock + 1) % 0x100000;
 }
 
-void SCI_METHOD Document::DecorationFillRange(int position, int value, int fillLength) {
+void SCI_METHOD Document::DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) {
 	if (decorations.FillRange(position, value, fillLength)) {
 		DocModification mh(SC_MOD_CHANGEINDICATOR | SC_PERFORMED_USER,
 							position, fillLength);
diff --git a/src/Document.h b/src/Document.h
index 308a67062..ea8ddfbed 100644
--- a/src/Document.h
+++ b/src/Document.h
@@ -270,7 +270,7 @@ public:
 
 	void SCI_METHOD SetErrorStatus(int status);
 
-	int SCI_METHOD LineFromPosition(int pos) const;
+	Sci_Position SCI_METHOD LineFromPosition(Sci_Position pos) const;
 	int ClampPositionIntoDocument(int pos) const;
 	bool IsCrLf(int pos) const;
 	int LenChar(int pos);
@@ -278,9 +278,9 @@ public:
 	int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true) const;
 	int NextPosition(int pos, int moveDir) const;
 	bool NextCharacter(int &pos, int moveDir) const;	// Returns true if pos changed
-	int SCI_METHOD GetRelativePosition(int positionStart, int characterOffset) const;
+	Sci_Position SCI_METHOD GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const;
 	int GetRelativePositionUTF16(int positionStart, int characterOffset) const;
-	int SCI_METHOD GetCharacterAndWidth(int position, int *pWidth) const;
+	int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const;
 	int SCI_METHOD CodePage() const;
 	bool SCI_METHOD IsDBCSLeadByte(char ch) const;
 	int SafeSegment(const char *text, int length, int lengthSegment) const;
@@ -292,7 +292,7 @@ public:
 	bool DeleteChars(int pos, int len);
 	int InsertString(int position, const char *s, int insertLength);
 	void ChangeInsertion(const char *s, int length);
-	int SCI_METHOD AddData(char *data, int length);
+	int SCI_METHOD AddData(char *data, Sci_Position length);
 	void * SCI_METHOD ConvertToDocument();
 	int Undo();
 	int Redo();
@@ -318,7 +318,7 @@ public:
 	const char *RangePointer(int position, int rangeLength) { return cb.RangePointer(position, rangeLength); }
 	int GapPosition() const { return cb.GapPosition(); }
 
-	int SCI_METHOD GetLineIndentation(int line);
+	int SCI_METHOD GetLineIndentation(Sci_Position line);
 	int SetLineIndentation(int line, int indent);
 	int GetLineIndentPosition(int line) const;
 	int GetColumn(int position);
@@ -335,10 +335,10 @@ public:
 	void DelCharBack(int pos);
 
 	char CharAt(int position) const { return cb.CharAt(position); }
-	void SCI_METHOD GetCharRange(char *buffer, int position, int lengthRetrieve) const {
+	void SCI_METHOD GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const {
 		cb.GetCharRange(buffer, position, lengthRetrieve);
 	}
-	char SCI_METHOD StyleAt(int position) const { return cb.StyleAt(position); }
+	char SCI_METHOD StyleAt(Sci_Position position) const { return cb.StyleAt(position); }
 	void GetStyleRange(unsigned char *buffer, int position, int lengthRetrieve) const {
 		cb.GetStyleRange(buffer, position, lengthRetrieve);
 	}
@@ -350,16 +350,16 @@ public:
 	void DeleteMarkFromHandle(int markerHandle);
 	void DeleteAllMarks(int markerNum);
 	int LineFromHandle(int markerHandle);
-	int SCI_METHOD LineStart(int line) const;
+	Sci_Position SCI_METHOD LineStart(Sci_Position line) const;
 	bool IsLineStartPosition(int position) const;
-	int SCI_METHOD LineEnd(int line) const;
+	Sci_Position SCI_METHOD LineEnd(Sci_Position line) const;
 	int LineEndPosition(int position) const;
 	bool IsLineEndPosition(int position) const;
 	bool IsPositionInLineEnd(int position) const;
 	int VCHomePosition(int position) const;
 
-	int SCI_METHOD SetLevel(int line, int level);
-	int SCI_METHOD GetLevel(int line) const;
+	int SCI_METHOD SetLevel(Sci_Position line, int level);
+	int SCI_METHOD GetLevel(Sci_Position line) const;
 	void ClearLevels();
 	int GetLastChild(int lineParent, int level=-1, int lastLine=-1);
 	int GetFoldParent(int line) const;
@@ -369,7 +369,7 @@ public:
 	int ExtendWordSelect(int pos, int delta, bool onlyWordCharacters=false);
 	int NextWordStart(int pos, int delta);
 	int NextWordEnd(int pos, int delta);
-	int SCI_METHOD Length() const { return cb.Length(); }
+	Sci_Position SCI_METHOD Length() const { return cb.Length(); }
 	void Allocate(int newSize) { cb.Allocate(newSize); }
 
 	struct CharacterExtracted {
@@ -395,9 +395,9 @@ public:
 	void SetDefaultCharClasses(bool includeWordClass);
 	void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass);
 	int GetCharsOfClass(CharClassify::cc characterClass, unsigned char *buffer);
-	void SCI_METHOD StartStyling(int position, char mask);
-	bool SCI_METHOD SetStyleFor(int length, char style);
-	bool SCI_METHOD SetStyles(int length, const char *styles);
+	void SCI_METHOD StartStyling(Sci_Position position, char mask);
+	bool SCI_METHOD SetStyleFor(Sci_Position length, char style);
+	bool SCI_METHOD SetStyles(Sci_Position length, const char *styles);
 	int GetEndStyled() const { return endStyled; }
 	void EnsureStyledTo(int pos);
 	void LexerChanged();
@@ -406,12 +406,12 @@ public:
 	void SCI_METHOD DecorationSetCurrentIndicator(int indicator) {
 		decorations.SetCurrentIndicator(indicator);
 	}
-	void SCI_METHOD DecorationFillRange(int position, int value, int fillLength);
+	void SCI_METHOD DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength);
 
-	int SCI_METHOD SetLineState(int line, int state);
-	int SCI_METHOD GetLineState(int line) const;
+	int SCI_METHOD SetLineState(Sci_Position line, int state);
+	int SCI_METHOD GetLineState(Sci_Position line) const;
 	int GetMaxLineState();
-	void SCI_METHOD ChangeLexerState(int start, int end);
+	void SCI_METHOD ChangeLexerState(Sci_Position start, Sci_Position end);
 
 	StyledText MarginStyledText(int line) const;
 	void MarginSetStyle(int line, int style);