A fix for attribrute sorting, but it's still broken if there are

[wxWidgets.git] / src / stc / scintilla / include / PropSet.h

diff --git a/src/stc/scintilla/include/PropSet.h b/src/stc/scintilla/include/PropSet.h
index bc1599f38a9fdba7bc04081bb6d3ee2f851b0073..025174f8abda8ff5b0851d61a97d1d9dc0e4bc3f 100644 (file)
--- a/src/stc/scintilla/include/PropSet.h
+++ b/src/stc/scintilla/include/PropSet.h
@@ -8,44 +8,92 @@
 
 bool EqualCaseInsensitive(const char *a, const char *b);
 
 
 bool EqualCaseInsensitive(const char *a, const char *b);
 

+#if PLAT_WIN
+#define strcasecmp  stricmp
+#define strncasecmp strnicmp
+#endif
+
+#ifdef __WXMSW__
+#define strcasecmp  stricmp
+#define strncasecmp strnicmp
+#endif
+

 // Define another string class.
 // While it would be 'better' to use std::string, that doubles the executable size.
 
 // Define another string class.
 // While it would be 'better' to use std::string, that doubles the executable size.
 

-inline char *StringDup(const char *s) {
+inline char *StringDup(const char *s, int len=-1) {

        if (!s)
                return 0;
        if (!s)
                return 0;

-       char *sNew = new char[strlen(s) + 1];
-       if (sNew)
-               strcpy(sNew, s);
+       if (len == -1)
+               len = strlen(s);
+       char *sNew = new char[len + 1];
+       if (sNew) {
+               strncpy(sNew, s, len);
+               sNew[len] = '\0';
+       }

        return sNew;
 }
 
 class SString {
        char *s;
        return sNew;
 }
 
 class SString {
        char *s;

+       int ssize;

 public:
 public:

+       typedef const char* const_iterator;
+       typedef int size_type;
+       static size_type npos;
+       const char* begin(void) const {
+               return s;
+       }
+       const char* end(void) const {
+               return &s[ssize];
+       }
+       size_type size(void) const {
+               if (s)
+                       return ssize;
+               else
+                       return 0;
+       }
+       SString &assign(const char* sother, int size_ = -1) {
+               char *t = s;
+               s = StringDup(sother,size_);
+               ssize = (s) ? strlen(s) : 0;
+               delete []t;
+               return *this;
+       }
+       SString &assign(const SString& sother, int size_ = -1) {
+               return assign(sother.s,size_);
+       }
+       SString &assign(const_iterator ibeg, const_iterator iend) {
+               return assign(ibeg,iend - ibeg);
+       }

        SString() {
                s = 0;
        SString() {
                s = 0;

+               ssize = 0;

        }
        SString(const SString &source) {
                s = StringDup(source.s);
        }
        SString(const SString &source) {
                s = StringDup(source.s);

+               ssize = (s) ? strlen(s) : 0;

        }
        SString(const char *s_) {
                s = StringDup(s_);
        }
        SString(const char *s_) {
                s = StringDup(s_);

+               ssize = (s) ? strlen(s) : 0;

        }
        SString(int i) {
                char number[100];
                sprintf(number, "%0d", i);
        }
        SString(int i) {
                char number[100];
                sprintf(number, "%0d", i);

-               //itoa(i, number, 10);

                s = StringDup(number);
                s = StringDup(number);

+               ssize = (s) ? strlen(s) : 0;

        }
        ~SString() {
                delete []s;
                s = 0;
        }
        ~SString() {
                delete []s;
                s = 0;

+               ssize = 0;

        }
        SString &operator=(const SString &source) {
                if (this != &source) {
                        delete []s;
                        s = StringDup(source.s);
        }
        SString &operator=(const SString &source) {
                if (this != &source) {
                        delete []s;
                        s = StringDup(source.s);

+                       ssize = (s) ? strlen(s) : 0;

                }
                return *this;
        }
                }
                return *this;
        }


@@ -56,6 +104,9 @@ public:
                        return false;
                return strcmp(s, other.s) == 0;
        }
                        return false;
                return strcmp(s, other.s) == 0;
        }

+       bool operator!=(const SString &other) const {
+               return !operator==(other);
+       }

        bool operator==(const char *sother) const {
                if ((s == 0) && (sother == 0))
                        return true;
        bool operator==(const char *sother) const {
                if ((s == 0) && (sother == 0))
                        return true;


@@ -63,6 +114,9 @@ public:
                        return false;
                return strcmp(s, sother) == 0;
        }
                        return false;
                return strcmp(s, sother) == 0;
        }

+       bool operator!=(const char *sother) const {
+               return !operator==(sother);
+       }

        const char *c_str() const {
                if (s)
                        return s;
        const char *c_str() const {
                if (s)
                        return s;


@@ -82,99 +136,109 @@ public:
                        return '\0';
        }
        SString &operator +=(const char *sother) {
                        return '\0';
        }
        SString &operator +=(const char *sother) {

+               return append(sother,-1);
+       }
+       SString &operator +=(const SString &sother) {
+               return append(sother.s,sother.ssize);
+       }
+       SString &operator +=(char ch) {
+               return append(&ch,1);
+       }
+       SString &append(const char* sother, int lenOther) {

                int len = length();
                int len = length();

-               int lenOther = strlen(sother);
+               if(lenOther < 0)
+                       lenOther = strlen(sother);

                char *sNew = new char[len + lenOther + 1];
                if (sNew) {
                        if (s)
                                memcpy(sNew, s, len);
                char *sNew = new char[len + lenOther + 1];
                if (sNew) {
                        if (s)
                                memcpy(sNew, s, len);

-                       memcpy(sNew + len, sother, lenOther);
+                       strncpy(&sNew[len], sother, lenOther);

                        sNew[len + lenOther] = '\0';
                        delete []s;
                        s = sNew;
                        sNew[len + lenOther] = '\0';
                        delete []s;
                        s = sNew;

+                       ssize = (s) ? strlen(s) : 0;

                }
                return *this;
        }
        int value() const {
                if (s)
                        return atoi(s);
                }
                return *this;
        }
        int value() const {
                if (s)
                        return atoi(s);

-               else 
+               else

                        return 0;
        }
                        return 0;
        }

+       void substitute(char find, char replace) {
+               char *t = s;
+               while (t) {
+                       t = strchr(t, find);
+                       if (t)
+                               *t = replace;
+               }
+       }
+       // I don't think this really belongs here -- Neil
+       void correctPath() {
+#ifdef unix
+               substitute('\\', '/');
+#else
+               substitute('/', '\\');
+#endif
+       }
+};
+
+struct Property {
+       unsigned int hash;
+       char *key;
+       char *val;
+       Property *next;
+       Property() : hash(0), key(0), val(0), next(0) {}

 };
 
 class PropSet {
 private:
 };
 
 class PropSet {
 private:

-       char **vals;
-       int size;
-       int used;
+       enum { hashRoots=31 };
+       Property *props[hashRoots];

 public:
        PropSet *superPS;
        PropSet();
        ~PropSet();
 public:
        PropSet *superPS;
        PropSet();
        ~PropSet();

-       void EnsureCanAddEntry();

        void Set(const char *key, const char *val);
        void Set(char *keyval);
        SString Get(const char *key);
        void Set(const char *key, const char *val);
        void Set(char *keyval);
        SString Get(const char *key);

+       SString GetExpanded(const char *key);
+       SString Expand(const char *withvars);

        int GetInt(const char *key, int defaultValue=0);
        SString GetWild(const char *keybase, const char *filename);
        SString GetNewExpand(const char *keybase, const char *filename);
        void Clear();
        int GetInt(const char *key, int defaultValue=0);
        SString GetWild(const char *keybase, const char *filename);
        SString GetNewExpand(const char *keybase, const char *filename);
        void Clear();

-       void ReadFromMemory(const char *data, int len);
-       void Read(const char *filename);
-};
-
-// This is a fixed length list of strings suitable for display  in combo boxes
-// as a memory of user entries
-template<int sz>
-class EntryMemory {
-       SString entries[sz];
-public:
-       void Insert(SString s) {
-               for (int i=0;i<sz;i++) {
-                       if (entries[i] == s) {
-                               for (int j=i;j>0;j--) {
-                                       entries[j] = entries[j-1];
-                               }
-                               entries[0] = s;
-                               return;
-                       }
-               }
-               for (int k=sz-1;k>0;k--) {
-                       entries[k] = entries[k-1];
-               }
-               entries[0] = s;
-       }
-       int Length() const {
-               int len = 0;
-               for (int i=0;i<sz;i++)
-                       if (entries[i].length())
-                               len++;
-               return len;
-       }
-       SString At(int n) const {
-               return entries[n];
-       }
+       void ReadFromMemory(const char *data, int len, const char *directoryForImports=0);
+       void Read(const char *filename, const char *directoryForImports);

 };
 
 class WordList {
 public:
        // Each word contains at least one character - a empty word acts as sentinal at the end.
        char **words;
 };
 
 class WordList {
 public:
        // Each word contains at least one character - a empty word acts as sentinal at the end.
        char **words;

+       char **wordsNoCase;

        char *list;
        int len;
        bool onlyLineEnds;      // Delimited by any white space or only line ends
        char *list;
        int len;
        bool onlyLineEnds;      // Delimited by any white space or only line ends

+       bool sorted;

        int starts[256];
        int starts[256];

-       WordList(bool onlyLineEnds_ = false) : 
-               words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) {}
+       WordList(bool onlyLineEnds_ = false) :
+               words(0), wordsNoCase(0), list(0), len(0), onlyLineEnds(onlyLineEnds_), sorted(false) {}

        ~WordList() { Clear(); }
        ~WordList() { Clear(); }

-       operator bool() { return list ? true : false; }
+       operator bool() { return words ? true : false; }

        const char *operator[](int ind) { return words[ind]; }
        void Clear();
        void Set(const char *s);
        char *Allocate(int size);
        void SetFromAllocated();
        bool InList(const char *s);
        const char *operator[](int ind) { return words[ind]; }
        void Clear();
        void Set(const char *s);
        char *Allocate(int size);
        void SetFromAllocated();
        bool InList(const char *s);

+       const char *GetNearestWord(const char *wordStart, int searchLen = -1, bool ignoreCase = false);
+       char *GetNearestWords(const char *wordStart, int searchLen = -1, bool ignoreCase = false);

 };
 
 };
 

+inline bool nonFuncChar(char ch) {
+       return strchr("\t\n\r !\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", ch) != NULL;
+}
+

 #endif
 #endif