Extract CharClassify::cc as CharacterClass and change to enum class.

5 files changed, 50 insertions, 49 deletions

diff --git a/src/CharClassify.cxx b/src/CharClassify.cxx
index b5e2870f3..f82fe75a6 100644
--- a/src/CharClassify.cxx
+++ b/src/CharClassify.cxx
@@ -21,29 +21,29 @@ CharClassify::CharClassify() : charClass{} {
 
 void CharClassify::SetDefaultCharClasses(bool includeWordClass) {
 	// Initialize all char classes to default values
-	for (int ch = 0; ch < 256; ch++) {
+	for (int ch = 0; ch < maxChar; ch++) {
 		if (ch == '\r' || ch == '\n')
-			charClass[ch] = ccNewLine;
+			charClass[ch] = CharacterClass::newLine;
 		else if (ch < 0x20 || ch == ' ')
-			charClass[ch] = ccSpace;
+			charClass[ch] = CharacterClass::space;
 		else if (includeWordClass && (ch >= 0x80 || IsAlphaNumeric(ch) || ch == '_'))
-			charClass[ch] = ccWord;
+			charClass[ch] = CharacterClass::word;
 		else
-			charClass[ch] = ccPunctuation;
+			charClass[ch] = CharacterClass::punctuation;
 	}
 }
 
-void CharClassify::SetCharClasses(const unsigned char *chars, cc newCharClass) {
+void CharClassify::SetCharClasses(const unsigned char *chars, CharacterClass newCharClass) {
 	// Apply the newCharClass to the specified chars
 	if (chars) {
 		while (*chars) {
-			charClass[*chars] = static_cast<unsigned char>(newCharClass);
+			charClass[*chars] = newCharClass;
 			chars++;
 		}
 	}
 }
 
-int CharClassify::GetCharsOfClass(cc characterClass, unsigned char *buffer) const noexcept {
+int CharClassify::GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const noexcept {
 	// Get characters belonging to the given char class; return the number
 	// of characters (if the buffer is NULL, don't write to it).
 	int count = 0;
diff --git a/src/CharClassify.h b/src/CharClassify.h
index 36cc34558..1fcdb9d5d 100644
--- a/src/CharClassify.h
+++ b/src/CharClassify.h
@@ -10,20 +10,21 @@
 
 namespace Scintilla {
 
+enum class CharacterClass : unsigned char { space, newLine, word, punctuation };
+
 class CharClassify {
 public:
 	CharClassify();
 
-	enum cc { ccSpace, ccNewLine, ccWord, ccPunctuation };
 	void SetDefaultCharClasses(bool includeWordClass);
-	void SetCharClasses(const unsigned char *chars, cc newCharClass);
-	int GetCharsOfClass(cc characterClass, unsigned char *buffer) const noexcept;
-	cc GetClass(unsigned char ch) const noexcept { return static_cast<cc>(charClass[ch]);}
-	bool IsWord(unsigned char ch) const noexcept { return static_cast<cc>(charClass[ch]) == ccWord;}
+	void SetCharClasses(const unsigned char *chars, CharacterClass newCharClass);
+	int GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const noexcept;
+	CharacterClass GetClass(unsigned char ch) const noexcept { return charClass[ch];}
+	bool IsWord(unsigned char ch) const noexcept { return charClass[ch] == CharacterClass::word;}
 
 private:
-	enum { maxChar=256 };
-	unsigned char charClass[maxChar];    // not type cc to save space
+	static constexpr int maxChar=256;
+	CharacterClass charClass[maxChar];
 };
 
 }
diff --git a/src/Document.cxx b/src/Document.cxx
index 4548064b5..0a4c8ca0b 100644
--- a/src/Document.cxx
+++ b/src/Document.cxx
@@ -1731,7 +1731,7 @@ Sci::Position Document::ParaDown(Sci::Position pos) const {
 		return LineEnd(line-1);
 }
 
-CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
+CharacterClass Document::WordCharacterClass(unsigned int ch) const {
 	if (dbcsCodePage && (!UTF8IsAscii(ch))) {
 		if (SC_CP_UTF8 == dbcsCodePage) {
 			// Use hard coded Unicode class
@@ -1741,7 +1741,7 @@ CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
 				// Separator, Line/Paragraph
 			case ccZl:
 			case ccZp:
-				return CharClassify::ccNewLine;
+				return CharacterClass::newLine;
 
 				// Separator, Space
 			case ccZs:
@@ -1751,7 +1751,7 @@ CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
 			case ccCs:
 			case ccCo:
 			case ccCn:
-				return CharClassify::ccSpace;
+				return CharacterClass::space;
 
 				// Letter
 			case ccLu:
@@ -1767,7 +1767,7 @@ CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
 			case ccMn:
 			case ccMc:
 			case ccMe:
-				return CharClassify::ccWord;
+				return CharacterClass::word;
 
 				// Punctuation
 			case ccPc:
@@ -1782,12 +1782,12 @@ CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
 			case ccSc:
 			case ccSk:
 			case ccSo:
-				return CharClassify::ccPunctuation;
+				return CharacterClass::punctuation;
 
 			}
 		} else {
 			// Asian DBCS
-			return CharClassify::ccWord;
+			return CharacterClass::word;
 		}
 	}
 	return charClass.GetClass(static_cast<unsigned char>(ch));
@@ -1798,7 +1798,7 @@ CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
  * Finds the start of word at pos when delta < 0 or the end of the word when delta >= 0.
  */
 Sci::Position Document::ExtendWordSelect(Sci::Position pos, int delta, bool onlyWordCharacters) const {
-	CharClassify::cc ccStart = CharClassify::ccWord;
+	CharacterClass ccStart = CharacterClass::word;
 	if (delta < 0) {
 		if (!onlyWordCharacters) {
 			const CharacterExtracted ce = CharacterBefore(pos);
@@ -1836,13 +1836,13 @@ Sci::Position Document::NextWordStart(Sci::Position pos, int delta) const {
 	if (delta < 0) {
 		while (pos > 0) {
 			const CharacterExtracted ce = CharacterBefore(pos);
-			if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+			if (WordCharacterClass(ce.character) != CharacterClass::space)
 				break;
 			pos -= ce.widthBytes;
 		}
 		if (pos > 0) {
 			CharacterExtracted ce = CharacterBefore(pos);
-			const CharClassify::cc ccStart = WordCharacterClass(ce.character);
+			const CharacterClass ccStart = WordCharacterClass(ce.character);
 			while (pos > 0) {
 				ce = CharacterBefore(pos);
 				if (WordCharacterClass(ce.character) != ccStart)
@@ -1852,7 +1852,7 @@ Sci::Position Document::NextWordStart(Sci::Position pos, int delta) const {
 		}
 	} else {
 		CharacterExtracted ce = CharacterAfter(pos);
-		const CharClassify::cc ccStart = WordCharacterClass(ce.character);
+		const CharacterClass ccStart = WordCharacterClass(ce.character);
 		while (pos < LengthNoExcept()) {
 			ce = CharacterAfter(pos);
 			if (WordCharacterClass(ce.character) != ccStart)
@@ -1861,7 +1861,7 @@ Sci::Position Document::NextWordStart(Sci::Position pos, int delta) const {
 		}
 		while (pos < LengthNoExcept()) {
 			ce = CharacterAfter(pos);
-			if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+			if (WordCharacterClass(ce.character) != CharacterClass::space)
 				break;
 			pos += ce.widthBytes;
 		}
@@ -1880,8 +1880,8 @@ Sci::Position Document::NextWordEnd(Sci::Position pos, int delta) const {
 	if (delta < 0) {
 		if (pos > 0) {
 			CharacterExtracted ce = CharacterBefore(pos);
-			const CharClassify::cc ccStart = WordCharacterClass(ce.character);
-			if (ccStart != CharClassify::ccSpace) {
+			const CharacterClass ccStart = WordCharacterClass(ce.character);
+			if (ccStart != CharacterClass::space) {
 				while (pos > 0) {
 					ce = CharacterBefore(pos);
 					if (WordCharacterClass(ce.character) != ccStart)
@@ -1891,7 +1891,7 @@ Sci::Position Document::NextWordEnd(Sci::Position pos, int delta) const {
 			}
 			while (pos > 0) {
 				ce = CharacterBefore(pos);
-				if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+				if (WordCharacterClass(ce.character) != CharacterClass::space)
 					break;
 				pos -= ce.widthBytes;
 			}
@@ -1899,13 +1899,13 @@ Sci::Position Document::NextWordEnd(Sci::Position pos, int delta) const {
 	} else {
 		while (pos < LengthNoExcept()) {
 			const CharacterExtracted ce = CharacterAfter(pos);
-			if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+			if (WordCharacterClass(ce.character) != CharacterClass::space)
 				break;
 			pos += ce.widthBytes;
 		}
 		if (pos < LengthNoExcept()) {
 			CharacterExtracted ce = CharacterAfter(pos);
-			const CharClassify::cc ccStart = WordCharacterClass(ce.character);
+			const CharacterClass ccStart = WordCharacterClass(ce.character);
 			while (pos < LengthNoExcept()) {
 				ce = CharacterAfter(pos);
 				if (WordCharacterClass(ce.character) != ccStart)
@@ -1926,10 +1926,10 @@ bool Document::IsWordStartAt(Sci::Position pos) const {
 		return false;
 	if (pos > 0) {
 		const CharacterExtracted cePos = CharacterAfter(pos);
-		const CharClassify::cc ccPos = WordCharacterClass(cePos.character);
+		const CharacterClass ccPos = WordCharacterClass(cePos.character);
 		const CharacterExtracted cePrev = CharacterBefore(pos);
-		const CharClassify::cc ccPrev = WordCharacterClass(cePrev.character);
-		return (ccPos == CharClassify::ccWord || ccPos == CharClassify::ccPunctuation) &&
+		const CharacterClass ccPrev = WordCharacterClass(cePrev.character);
+		return (ccPos == CharacterClass::word || ccPos == CharacterClass::punctuation) &&
 			(ccPos != ccPrev);
 	}
 	return true;
@@ -1944,10 +1944,10 @@ bool Document::IsWordEndAt(Sci::Position pos) const {
 		return false;
 	if (pos < LengthNoExcept()) {
 		const CharacterExtracted cePos = CharacterAfter(pos);
-		const CharClassify::cc ccPos = WordCharacterClass(cePos.character);
+		const CharacterClass ccPos = WordCharacterClass(cePos.character);
 		const CharacterExtracted cePrev = CharacterBefore(pos);
-		const CharClassify::cc ccPrev = WordCharacterClass(cePrev.character);
-		return (ccPrev == CharClassify::ccWord || ccPrev == CharClassify::ccPunctuation) &&
+		const CharacterClass ccPrev = WordCharacterClass(cePrev.character);
+		return (ccPrev == CharacterClass::word || ccPrev == CharacterClass::punctuation) &&
 			(ccPrev != ccPos);
 	}
 	return true;
@@ -2186,11 +2186,11 @@ void Document::SetDefaultCharClasses(bool includeWordClass) {
     charClass.SetDefaultCharClasses(includeWordClass);
 }
 
-void Document::SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass) {
+void Document::SetCharClasses(const unsigned char *chars, CharacterClass newCharClass) {
     charClass.SetCharClasses(chars, newCharClass);
 }
 
-int Document::GetCharsOfClass(CharClassify::cc characterClass, unsigned char *buffer) const {
+int Document::GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const {
     return charClass.GetCharsOfClass(characterClass, buffer);
 }
 
@@ -2528,7 +2528,7 @@ static bool IsASCIIPunctuationCharacter(unsigned int ch) noexcept {
 }
 
 bool Document::IsWordPartSeparator(unsigned int ch) const {
-	return (WordCharacterClass(ch) == CharClassify::ccWord) && IsASCIIPunctuationCharacter(ch);
+	return (WordCharacterClass(ch) == CharacterClass::word) && IsASCIIPunctuationCharacter(ch);
 }
 
 Sci::Position Document::WordPartLeft(Sci::Position pos) const {
diff --git a/src/Document.h b/src/Document.h
index 91163713b..e2d9eddce 100644
--- a/src/Document.h
+++ b/src/Document.h
@@ -448,8 +448,8 @@ public:
 	Sci::Line LinesTotal() const noexcept;
 
 	void SetDefaultCharClasses(bool includeWordClass);
-	void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass);
-	int GetCharsOfClass(CharClassify::cc characterClass, unsigned char *buffer) const;
+	void SetCharClasses(const unsigned char *chars, CharacterClass newCharClass);
+	int GetCharsOfClass(CharacterClass characterClass, unsigned char *buffer) const;
 	void SetCharacterCategoryOptimization(int countCharacters);
 	int CharacterCategoryOptimization() const noexcept;
 	void SCI_METHOD StartStyling(Sci_Position position) override;
@@ -492,7 +492,7 @@ public:
 	bool AddWatcher(DocWatcher *watcher, void *userData);
 	bool RemoveWatcher(DocWatcher *watcher, void *userData);
 
-	CharClassify::cc WordCharacterClass(unsigned int ch) const;
+	CharacterClass WordCharacterClass(unsigned int ch) const;
 	bool IsWordPartSeparator(unsigned int ch) const;
 	Sci::Position WordPartLeft(Sci::Position pos) const;
 	Sci::Position WordPartRight(Sci::Position pos) const;
diff --git a/src/Editor.cxx b/src/Editor.cxx
index 4f1add2c3..dcaa6fc6b 100644
--- a/src/Editor.cxx
+++ b/src/Editor.cxx
@@ -6294,33 +6294,33 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_GETWORDCHARS:
-		return pdoc->GetCharsOfClass(CharClassify::ccWord, UCharPtrFromSPtr(lParam));
+		return pdoc->GetCharsOfClass(CharacterClass::word, UCharPtrFromSPtr(lParam));
 
 	case SCI_SETWORDCHARS: {
 			pdoc->SetDefaultCharClasses(false);
 			if (lParam == 0)
 				return 0;
-			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharClassify::ccWord);
+			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharacterClass::word);
 		}
 		break;
 
 	case SCI_GETWHITESPACECHARS:
-		return pdoc->GetCharsOfClass(CharClassify::ccSpace, UCharPtrFromSPtr(lParam));
+		return pdoc->GetCharsOfClass(CharacterClass::space, UCharPtrFromSPtr(lParam));
 
 	case SCI_SETWHITESPACECHARS: {
 			if (lParam == 0)
 				return 0;
-			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharClassify::ccSpace);
+			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharacterClass::space);
 		}
 		break;
 
 	case SCI_GETPUNCTUATIONCHARS:
-		return pdoc->GetCharsOfClass(CharClassify::ccPunctuation, UCharPtrFromSPtr(lParam));
+		return pdoc->GetCharsOfClass(CharacterClass::punctuation, UCharPtrFromSPtr(lParam));
 
 	case SCI_SETPUNCTUATIONCHARS: {
 			if (lParam == 0)
 				return 0;
-			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharClassify::ccPunctuation);
+			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharacterClass::punctuation);
 		}
 		break;