Added defines to allow altered tab placement under gcc-2.95

[wxWidgets.git] / include / wx / string.h

diff --git a/include/wx/string.h b/include/wx/string.h
index fa68ee7ccff403b1d2e0db96856b7abff4a92771..993e8a928323722de720c1a754a6b48f46663fd3 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -20,6 +20,10 @@
     #include <ctype.h>
 #endif
 
     #include <ctype.h>
 #endif
 

+#ifdef __EMX__
+    #include <std.h>
+#endif
+

 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>


@@ -73,6 +77,9 @@ const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
 // implementation only
 #define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )
 
 // implementation only
 #define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )
 

+// include conversion classes
+#include "wx/strconv.h"
+

 // ---------------------------------------------------------------------------
 // Global functions complementing standard C string library replacements for
 // strlen() and portable strcasecmp()
 // ---------------------------------------------------------------------------
 // Global functions complementing standard C string library replacements for
 // strlen() and portable strcasecmp()


@@ -89,17 +96,21 @@ inline size_t WXDLLEXPORT Strlen(const char *psz)
 // portable strcasecmp/_stricmp
 inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
 {
 // portable strcasecmp/_stricmp
 inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
 {

-#if     defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
+#if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )

   return _stricmp(psz1, psz2);
   return _stricmp(psz1, psz2);

-#elif     defined(__SC__)
+#elif defined(__SC__)

   return _stricmp(psz1, psz2);
   return _stricmp(psz1, psz2);

-#elif     defined(__SALFORDC__)
+#elif defined(__SALFORDC__)

   return stricmp(psz1, psz2);
 #elif defined(__BORLANDC__)
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);
   return stricmp(psz1, psz2);
 #elif defined(__BORLANDC__)
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);

-#elif   defined(__UNIX__) || defined(__GNUWIN32__)
+#elif defined(__EMX__)
+  return stricmp(psz1, psz2);
+#elif defined(__WXPM__)
+  return stricmp(psz1, psz2);
+#elif defined(__UNIX__) || defined(__GNUWIN32__)

   return strcasecmp(psz1, psz2);
 #elif defined(__MWERKS__) && !defined(__INTEL__)
   register char c1, c2;
   return strcasecmp(psz1, psz2);
 #elif defined(__MWERKS__) && !defined(__INTEL__)
   register char c1, c2;


@@ -167,101 +178,6 @@ struct WXDLLEXPORT wxStringData
   bool  IsValid() const   { return (nRefs != 0); }
 };
 
   bool  IsValid() const   { return (nRefs != 0); }
 };
 

-// ---------------------------------------------------------------------------
-// types of multibyte<->Unicode conversions
-// ---------------------------------------------------------------------------
-#if wxUSE_WCHAR_T
-class WXDLLEXPORT wxMBConv
-{
- public:
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
-  // No longer inline since BC++ complains.
-  const wxWCharBuffer cMB2WC(const char *psz) const;
-  const wxCharBuffer cWC2MB(const wchar_t *psz) const;
-#if wxUSE_UNICODE
-  const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
-  const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
-  const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; }
-  const wchar_t* cMB2WC(const wchar_t *psz) const { return psz; }
-#else
-  const char* cMB2WX(const char *psz) const { return psz; }
-  const char* cWX2MB(const char *psz) const { return psz; }
-  const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
-  const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }
-#endif
-};
-WXDLLEXPORT_DATA(extern wxMBConv) wxConvLibc;
-#define wxConv_libc wxConvLibc
-
-#define wxANOTHER_MBCONV(type) \
-class type : public wxMBConv { \
- public: \
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; \
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; \
-}
-
-WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConvFile)) wxConvFile;
-#define wxConv_file wxConvFile
-WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConvUTF7)) wxConvUTF7;
-WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConvUTF8)) wxConvUTF8;
-#define wxConv_UTF8 wxConvUTF8
-#if defined(__WXGTK12__)
-    WXDLLEXPORT_DATA(extern wxANOTHER_MBCONV(wxMBConvGdk)) wxConvGdk;
-    #define wxConv_gdk wxConvGdk
-#endif // GTK > 1.0
-
-class wxCharacterSet;
-class WXDLLEXPORT wxCSConv : public wxMBConv
-{
- private:
-  wxChar *m_name;
-  wxCharacterSet *m_cset;
-  bool m_deferred;
-  void SetName(const wxChar *charset);
- public:
-  wxCSConv(const wxChar *charset);
-  virtual ~wxCSConv();
-  void LoadNow();
-  virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
-  virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
-};
-
-WXDLLEXPORT_DATA(extern wxCSConv) wxConvLocal;
-#define wxConv_local wxConvLocal
-
-WXDLLEXPORT_DATA(extern wxMBConv *) wxConvCurrent;
-#define wxConv_current wxConvCurrent
-
-// filenames are multibyte on Unix and probably widechar on Windows?
-#if defined(__UNIX__) || defined(__BORLANDC__)
-#define wxMBFILES 1
-#else
-#define wxMBFILES 0
-#endif
-
-#if wxMBFILES
-#define wxFNCONV(name) wxConvFile.cWX2MB(name)
-#define FNSTRINGCAST MBSTRINGCAST
-#else
-#define wxFNCONV(name) name
-#define FNSTRINGCAST WXSTRINGCAST
-#endif
-#else//!wxUSE_WCHAR_T
-class WXDLLEXPORT wxMBConv {
-public:
-  const char* cMB2WX(const char *psz) const { return psz; }
-  const char* cWX2MB(const char *psz) const { return psz; }
-};
-WXDLLEXPORT_DATA(extern wxMBConv) wxConvLibc, wxConvFile;
-#define wxConv_libc wxConvLibc
-#define wxConv_file wxConvFile
-WXDLLEXPORT_DATA(extern wxMBConv *) wxConvCurrent;
-#define wxConv_current wxConvCurrent
-#define wxFNCONV(name) name
-#define FNSTRINGCAST WXSTRINGCAST
-#endif//wxUSE_WCHAR_T
-

 // ---------------------------------------------------------------------------
 // This is (yet another one) String class for C++ programmers. It doesn't use
 // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
 // ---------------------------------------------------------------------------
 // This is (yet another one) String class for C++ programmers. It doesn't use
 // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)


@@ -573,13 +489,19 @@ public:
 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
 
   // string comparison
     // case-sensitive comparison (returns a value < 0, = 0 or > 0)

-  int  Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
+  int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }

     // same as Cmp() but not case-sensitive
     // same as Cmp() but not case-sensitive

-  int  CmpNoCase(const wxChar *psz) const { return Stricmp(c_str(), psz); }
+  int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }

     // test for the string equality, either considering case or not
     // (if compareWithCase then the case matters)
   bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
     // test for the string equality, either considering case or not
     // (if compareWithCase then the case matters)
   bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }

+    // comparison with a signle character: returns TRUE if equal
+  bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
+    {
+      return (Len() == 1) && (compareWithCase ? GetChar(0u) == c
+                              : wxToupper(GetChar(0u)) == wxToupper(c));
+    }

 
   // simple sub-string extraction
       // return substring starting at nFirst of length nCount (or till the end
 
   // simple sub-string extraction
       // return substring starting at nFirst of length nCount (or till the end


@@ -713,6 +635,10 @@ public:
 #ifdef  wxSTD_STRING_COMPATIBILITY
   // std::string compatibility functions
 
 #ifdef  wxSTD_STRING_COMPATIBILITY
   // std::string compatibility functions
 

+  // standard types
+  typedef wxChar value_type;
+  typedef const value_type *const_iterator;
+

   // an 'invalid' value for string index
   static const size_t npos;
 
   // an 'invalid' value for string index
   static const size_t npos;
 


@@ -746,6 +672,11 @@ public:
     // returns the writable character at position n
   wxChar& at(size_t n) { return GetWritableChar(n); }
 
     // returns the writable character at position n
   wxChar& at(size_t n) { return GetWritableChar(n); }
 

+    // first valid index position
+  const_iterator begin() const { return wx_str(); }
+    // position one after the last valid one
+  const_iterator end() const { return wx_str() + length(); }
+

   // lib.string.modifiers
     // append a string
   wxString& append(const wxString& str)
   // lib.string.modifiers
     // append a string
   wxString& append(const wxString& str)


@@ -985,6 +916,7 @@ private:
 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------

+

 //
 inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) == 0); }
 //
 //
 inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) == 0); }
 //


@@ -1022,6 +954,24 @@ inline bool operator>=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(
 //
 inline bool operator>=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) <= 0); }
 
 //
 inline bool operator>=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) <= 0); }
 

+// comparison with char
+inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
+inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
+inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
+inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
+
+#if wxUSE_UNICODE
+inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
+    { return (s1.Cmp((const wchar_t *)s2) == 0); }
+inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
+    { return (s2.Cmp((const wchar_t *)s1) == 0); }
+#else
+inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
+    { return (s1.Cmp((const char *)s2) == 0); }
+inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
+    { return (s2.Cmp((const char *)s1) == 0); }
+#endif
+

 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
 wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
 wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);


@@ -1043,7 +993,7 @@ inline wxString WXDLLEXPORT operator+(const wxCharBuffer& buf, const wxString& s
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 

-#ifdef wxSTD_STRING_COMPATIBILITY
+#if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM

 
 #include "wx/ioswrap.h"
 
 
 #include "wx/ioswrap.h"