Initial copy of Scintilla 3.21 code

[wxWidgets.git] / src / stc / scintilla / lexlib / CharacterSet.h

diff --git a/src/stc/scintilla/lexlib/CharacterSet.h b/src/stc/scintilla/lexlib/CharacterSet.h
new file mode 100644 (file)
index 0000000..a0c45b2
--- /dev/null
+++ b/src/stc/scintilla/lexlib/CharacterSet.h
@@ -0,0 +1,177 @@
+// Scintilla source code edit control
+/** @file CharacterSet.h
+ ** Encapsulates a set of characters. Used to test if a character is within a set.
+ **/
+// Copyright 2007 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CHARACTERSET_H
+#define CHARACTERSET_H
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+class CharacterSet {
+       int size;
+       bool valueAfter;
+       bool *bset;
+public:
+       enum setBase {
+               setNone=0,
+               setLower=1,
+               setUpper=2,
+               setDigits=4,
+               setAlpha=setLower|setUpper,
+               setAlphaNum=setAlpha|setDigits
+       };
+       CharacterSet(setBase base=setNone, const char *initialSet="", int size_=0x80, bool valueAfter_=false) {
+               size = size_;
+               valueAfter = valueAfter_;
+               bset = new bool[size];
+               for (int i=0; i < size; i++) {
+                       bset[i] = false;
+               }
+               AddString(initialSet);
+               if (base & setLower)
+                       AddString("abcdefghijklmnopqrstuvwxyz");
+               if (base & setUpper)
+                       AddString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+               if (base & setDigits)
+                       AddString("0123456789");
+       }
+       CharacterSet(const CharacterSet &other) {
+               size = other.size;
+               valueAfter = other.valueAfter;
+               bset = new bool[size];
+               for (int i=0; i < size; i++) {
+                       bset[i] = other.bset[i];
+               }
+       }
+       ~CharacterSet() {
+               delete []bset;
+               bset = 0;
+               size = 0;
+       }
+       CharacterSet &operator=(const CharacterSet &other) {
+               if (this != &other) {
+                       bool *bsetNew = new bool[other.size];
+                       for (int i=0; i < other.size; i++) {
+                               bsetNew[i] = other.bset[i];
+                       }
+                       delete []bset;
+                       size = other.size;
+                       valueAfter = other.valueAfter;
+                       bset = bsetNew;
+               }
+               return *this;
+       }
+       void Add(int val) {
+               assert(val >= 0);
+               assert(val < size);
+               bset[val] = true;
+       }
+       void AddString(const char *setToAdd) {
+               for (const char *cp=setToAdd; *cp; cp++) {
+                       int val = static_cast<unsigned char>(*cp);
+                       assert(val >= 0);
+                       assert(val < size);
+                       bset[val] = true;
+               }
+       }
+       bool Contains(int val) const {
+               assert(val >= 0);
+               if (val < 0) return false;
+               return (val < size) ? bset[val] : valueAfter;
+       }
+};
+
+// Functions for classifying characters
+
+inline bool IsASpace(int ch) {
+    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
+}
+
+inline bool IsASpaceOrTab(int ch) {
+       return (ch == ' ') || (ch == '\t');
+}
+
+inline bool IsADigit(int ch) {
+       return (ch >= '0') && (ch <= '9');
+}
+
+inline bool IsADigit(int ch, int base) {
+       if (base <= 10) {
+               return (ch >= '0') && (ch < '0' + base);
+       } else {
+               return ((ch >= '0') && (ch <= '9')) ||
+                      ((ch >= 'A') && (ch < 'A' + base - 10)) ||
+                      ((ch >= 'a') && (ch < 'a' + base - 10));
+       }
+}
+
+inline bool IsASCII(int ch) {
+       return (ch >= 0) && (ch < 0x80);
+}
+
+inline bool IsLowerCase(int ch) {
+       return (ch >= 'a') && (ch <= 'z');
+}
+
+inline bool IsUpperCase(int ch) {
+       return (ch >= 'A') && (ch <= 'Z');
+}
+
+inline bool IsAlphaNumeric(int ch) {
+       return
+               ((ch >= '0') && (ch <= '9')) ||
+               ((ch >= 'a') && (ch <= 'z')) ||
+               ((ch >= 'A') && (ch <= 'Z'));
+}
+
+/**
+ * Check if a character is a space.
+ * This is ASCII specific but is safe with chars >= 0x80.
+ */
+inline bool isspacechar(int ch) {
+    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
+}
+
+inline bool iswordchar(int ch) {
+       return IsAlphaNumeric(ch) || ch == '.' || ch == '_';
+}
+
+inline bool iswordstart(int ch) {
+       return IsAlphaNumeric(ch) || ch == '_';
+}
+
+inline bool isoperator(int ch) {
+       if (IsAlphaNumeric(ch))
+               return false;
+       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;
+}
+
+// Simple case functions for ASCII.
+
+inline char MakeUpperCase(char ch) {
+       if (ch < 'a' || ch > 'z')
+               return ch;
+       else
+               return static_cast<char>(ch - 'a' + 'A');
+}
+
+int CompareCaseInsensitive(const char *a, const char *b);
+int CompareNCaseInsensitive(const char *a, const char *b, size_t len);
+
+#ifdef SCI_NAMESPACE
+}
+#endif
+
+#endif