* New wxStream classes: wxStreamBuffer and wxObject*Stream.

* Changes: ofsInvalid => wxInvalidOffset in filefn.h
* Updates: all wxStream classes use wxStreamBuffer.
           wxObject basic declaration changes (added LoadObject, modified
           StoreObject)
* Some base of the serialization.
(I hope not to have forgotten any files)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@361 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/file.h

@@ -21,6 +21,8 @@
 #include  "wx/filefn.h"
 
 // ----------------------------------------------------------------------------
+<<<<<<< file.h
+=======
 // constants
 // ----------------------------------------------------------------------------
 
@@ -45,6 +47,7 @@ const off_t ofsInvalid = (off_t)-1;
 #define wxS_DEFAULT   (wxS_IRUSR | wxS_IWUSR | wxS_IRGRP | wxS_IROTH)
 
 // ----------------------------------------------------------------------------
+>>>>>>> 1.7
 // class wxFile: raw file IO
 //
 // NB: for space efficiency this class has no virtual functions, including
@@ -75,6 +78,11 @@ public:
   wxFile(int fd) { m_fd = fd; }
 
   // open/close
+<<<<<<< file.h
+  bool Create(const char *szFileName, bool bOverwrite = FALSE);
+  bool Open(const char *szFileName, OpenMode mode = read);
+  inline bool Close();  // Close is a NOP if not opened
+=======
     // create a new file (with the default value of bOverwrite, it will fail if
     // the file already exists, otherwise it will overwrite it and succeed)
   bool Create(const char *szFileName, bool bOverwrite = FALSE,
@@ -82,6 +90,7 @@ public:
   bool Open(const char *szFileName, OpenMode mode = read,
             int access = wxS_DEFAULT);
   bool Close();  // Close is a NOP if not opened
+>>>>>>> 1.7
 
   // assign an existing file descriptor and get it back from wxFile object
   void Attach(int fd) { Close(); m_fd = fd; }

include/wx/filefn.h

@@ -29,6 +29,8 @@
   #define   off_t       _off_t
 #endif
 
+const off_t wxInvalidOffset = (off_t)-1;
+
 typedef enum {
   wxFromStart,
   wxFromCurrent,
@@ -71,7 +73,6 @@ void WXDLLEXPORT wxUnix2DosFilename(char *s);
 
 // Strip the extension, in situ
 void WXDLLEXPORT wxStripExtension(char *buffer);
-void WXDLLEXPORT wxStripExtension(wxString& buffer);
 
 // Get a temporary filename, opening and closing the file.
 char* WXDLLEXPORT wxGetTempFileName(const wxString& prefix, char *buf = NULL);

include/wx/fstream.h

@@ -16,51 +16,44 @@
 #include <wx/stream.h>
 #include <wx/file.h>
 
-class wxFileInputStream: virtual public wxFile, public wxInputStream {
+class wxFileInputStream: public wxInputStream, virtual public wxFile {
  public:
   wxFileInputStream(const wxString& fileName);
   virtual ~wxFileInputStream();
 
-  wxInputStream& Read(void *buffer, size_t size);
+  virtual char Peek();
-  off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
-  off_t TellI() const;
 
-  bool Eof() const { return m_eof; }
+  virtual bool Eof() const { return wxFile::Eof(); }
-  size_t LastRead() const { return m_lastread; }
 
   bool Ok() const { return wxFile::IsOpened(); }
 
  protected:
   wxFileInputStream() {}
 
- protected:
+  size_t DoRead(void *buffer, size_t size);
-  bool m_eof;
+  off_t DoSeekInput(off_t pos, wxSeekMode mode);
-  bool m_ok_i;
+  off_t DoTellInput() const;
-  size_t m_lastread;
 };
 
-class wxFileOutputStream: virtual wxFile, public wxOutputStream {
+class wxFileOutputStream: public wxOutputStream, virtual public wxFile {
  public:
   wxFileOutputStream(const wxString& fileName);
   virtual ~wxFileOutputStream();
 
-  wxOutputStream& Write(const void *buffer, size_t size);
+  // To solve an ambiguity on GCC
-  off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
+  inline wxOutputStream& Write(const void *buffer, size_t size)
-  off_t TellO() const;
+     { return wxOutputStream::Write(buffer, size); }
-
-  bool Bad() const { return m_bad; }
-  size_t LastWrite() const { return m_lastwrite; }
 
   void Sync();
 
-  bool IsOpened() const { return wxFile::IsOpened(); }
+  bool Ok() const { return wxFile::IsOpened(); }
 
  protected:
   wxFileOutputStream() {}
 
- protected:
+  size_t DoWrite(const void *buffer, size_t size);
-  bool m_bad;
+  off_t DoSeekOutput(off_t pos, wxSeekMode mode);
-  size_t m_lastwrite;
+  off_t DoTellOutput() const;
 };
 
 class wxFileStream: public wxFileInputStream, public wxFileOutputStream {

include/wx/mstream.h

@@ -31,18 +31,15 @@ class wxMemoryInputStream: virtual public wxMemoryStreamBase, public wxInputStre
  public:
   wxMemoryInputStream(const char *data, size_t length);
   virtual ~wxMemoryInputStream();
- 
-  wxInputStream& Read(void *buffer, size_t size);
-  off_t SeekI(off_t pos, wxSeekMode mode);
-  off_t TellI() const { return m_position_i; }
-
-  bool Eof() const { return m_eof; }
-  size_t LastRead() const { return m_lastread; }
 
  protected:
-  bool m_eof;
+ 
+  size_t DoRead(void *buffer, size_t size);
+  off_t DoSeekInput(off_t pos, wxSeekMode mode);
+  off_t DoTellInput() const { return m_position_i; }
+
+ protected:
   off_t m_position_i;
-  size_t m_lastread;
 };
 
 class wxMemoryOutputStream: virtual public wxMemoryStreamBase, public wxOutputStream {
@@ -50,20 +47,17 @@ class wxMemoryOutputStream: virtual public wxMemoryStreamBase, public wxOutputSt
   wxMemoryOutputStream(char *data = NULL, size_t length = 0);
   virtual ~wxMemoryOutputStream();
 
-  wxOutputStream& Write(const void *buffer, size_t size);
+  char *GetData() { Sync(); return m_buffer; }
-  off_t SeekO(off_t pos, wxSeekMode mode);
+  size_t GetLength() { Sync(); return m_length; }
-  off_t TellO() const { return m_position_o; }
+
-
+ protected:
-  bool Bad() const { return m_bad; }
+
-  size_t LastWrite() const { return m_lastwrite; }
+  size_t DoWrite(const void *buffer, size_t size);
-
+  off_t DoSeekOutput(off_t pos, wxSeekMode mode);
-  char *GetData() { return m_buffer; }
+  off_t DoTellOutput() const { return m_position_o; }
-  size_t GetLength() { return m_length; }
 
  protected:
-  bool m_bad;
   off_t m_position_o;
-  size_t m_lastwrite;
 };
 
 class wxMemoryStream: public wxMemoryInputStream, public wxMemoryOutputStream {

include/wx/object.h

@@ -29,9 +29,10 @@ class WXDLLEXPORT wxObject;
 #endif
 
 class WXDLLEXPORT wxClassInfo;
-
+class WXDLLEXPORT ostream;
-class WXDLLIMPORT istream;
+class WXDLLEXPORT wxInputStream;
-class WXDLLIMPORT ostream;
+class WXDLLIMPORT wxObjectInputStream;
+class WXDLLIMPORT wxObjectOutputStream;
 
 /*
  * Dynamic object system declarations
@@ -39,10 +40,6 @@ class WXDLLIMPORT ostream;
 
 typedef wxObject * (*wxObjectConstructorFn) (void);
 
-#ifdef USE_STORABLE_CLASSES
-typedef wxObject* (*wxStorableConstructorFn) ( istream &stream, char *data );
-#endif
-
 class WXDLLEXPORT wxClassInfo
 {
  public:
@@ -52,10 +49,6 @@ class WXDLLEXPORT wxClassInfo
    int objectSize;
    wxObjectConstructorFn objectConstructor;
    
-#ifdef USE_STORABLE_CLASSES
-  wxStorableConstructorFn storableConstructor;
-#endif
-
    // Pointers to base wxClassInfos: set in InitializeClasses
    // called from wx_main.cc
    wxClassInfo *baseInfo1;
@@ -64,19 +57,10 @@ class WXDLLEXPORT wxClassInfo
    static wxClassInfo *first;
    wxClassInfo *next;
 
-#ifdef USE_STORABLE_CLASSES
-   wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn fn,
-     wxStorableConstructorFn stoFn = NULL );
-#else
    wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn fn);
-#endif
 
    wxObject *CreateObject(void);
    
-#ifdef USE_STORABLE_CLASSES
-   wxObject* CreateObject( istream &stream, char *data );
-#endif
-
    inline char *GetClassName(void) const { return className; }
    inline char *GetBaseClassName1(void) const { return baseClassName1; }
    inline char *GetBaseClassName2(void) const { return baseClassName2; }
@@ -91,7 +75,7 @@ class WXDLLEXPORT wxClassInfo
 wxObject* WXDLLEXPORT wxCreateDynamicObject(char *name);
 
 #ifdef USE_STORABLE_CLASSES
-wxObject* WXDLLEXPORT wxCreateStoredObject( char *name, istream &stream, char *data );
+wxObject* WXDLLEXPORT wxCreateStoredObject( wxInputStream& stream );
 #endif
 
 #define DECLARE_DYNAMIC_CLASS(name) \
@@ -103,10 +87,6 @@ wxObject* WXDLLEXPORT wxCreateStoredObject( char *name, istream &stream, char *d
 #define DECLARE_ABSTRACT_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
 #define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
 
-#ifdef USE_STORABLE_CLASSES
-#define DECLARE_STORABLECLASS(name) DECLARE_DYNAMIC_CLASS(name)
-#endif
-
 //////
 ////// for concrete classes
 //////
@@ -123,30 +103,6 @@ wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void) \
    { return new name; }\
  wxClassInfo name::class##name(#name, #basename1, #basename2, sizeof(name), wxConstructorFor##name);
 
-//////
-////// for storable classes
-//////
-
-#ifdef USE_STORABLE_CLASSES
-
-#define IMPLEMENT_STORABLE_CLASS(name, basename) \
-wxObject* WXDLLEXPORT_CTORFN wxStorableConstructorFor##name( istream* stream, char* data )\
-	{ return new name( stream, data ); }\
-wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void)\
-   { return new name; }\
- wxClassInfo name::class##name(#name, #basename, NULL, sizeof(name), wxConstructorFor##name,\
-   wxStorableConstructorFor##name );
-
-#define IMPLEMENT_STORABLE_CLASS2(name, basename1, basename2) \
-wxObject* WXDLLEXPORT_CTORFN wxStorableConstructorFor##name( istream* stream, char* data )\
-	{ return new name( stream, data ); }\
-wxObject* WXDLLEXPORT_CTORFN wxConstructorFor##name(void)\
-   { return new name; }\
- wxClassInfo name::class##name(#name, #basename1, basename2, sizeof(name), wxConstructorFor##name,\
-   wxStorableConstructorFor##name );
-
-#endif
- 
 //////
 ////// for abstract classes
 //////
@@ -223,7 +179,8 @@ class WXDLLEXPORT wxObject
 #endif
 
 #ifdef USE_STORABLE_CLASSES
-  virtual void StoreObject( ostream &WXUNUSED(stream) ) {};
+  virtual void StoreObject( wxObjectOutputStream &WXUNUSED(stream) ) {};
+  virtual void LoadObject( wxObjectInputStream &WXUNUSED(stream) ) {};
 #endif
 
   // make a 'clone' of the object

include/wx/stream.h

@@ -19,84 +19,187 @@
 #include <stdio.h>
 #include "wx/object.h"
 #include "wx/string.h"
-#include "wx/filefn.h"  // for off_t and wxSeekMode
+#include "wx/filefn.h"  // for off_t, wxInvalidOffset and wxSeekMode
+
+class WXDLLEXPORT wxInputStream;
+class WXDLLEXPORT wxOutputStream;
+
+typedef wxInputStream& (*__wxInputManip)(wxInputStream&);
+typedef wxOutputStream& (*__wxOutputManip)(wxOutputStream&);
+
+wxOutputStream& WXDLLEXPORT wxEndL(wxOutputStream& o_stream);
+
+class WXDLLEXPORT wxStreamBuffer {
+ public:
+  wxStreamBuffer(wxInputStream& stream);
+  wxStreamBuffer(wxOutputStream& stream);
+  ~wxStreamBuffer();
+
+  void Read(void *buffer, size_t size);
+  void Write(const void *buffer, size_t size);
+  void WriteBack(char c);
+
+  void SetBufferIO(char *buffer_start, char *buffer_end);
+  void SetBufferIO(size_t bufsize);
+  void ResetBuffer(); 
+
+  void SetBufferPosition(char *buffer_position)
+                                  { m_buffer_pos = buffer_position; }
+  void SetIntPosition(size_t pos)
+                     { m_buffer_pos = m_buffer_start + pos; }
+  char *GetBufferPosition() const { return m_buffer_pos; }
+  size_t GetIntPosition() const { return m_buffer_pos - m_buffer_start; }
+  
+  char *GetBufferStart() const    { return m_buffer_start; }
+  char *GetBufferEnd() const      { return m_buffer_end; }
+  size_t GetBufferSize() const    { return m_buffer_size; }
+  size_t GetLastAccess() const      { return m_buffer_end - m_buffer_start; }
+
+ protected:
+  char *m_buffer_start, *m_buffer_end, *m_buffer_pos;
+  size_t m_buffer_size;
+
+  wxInputStream *m_istream;
+  wxOutputStream *m_ostream;
+};
 
 /*
  * wxStream: base classes
  */
-class wxOutputStream;
+class WXDLLEXPORT wxInputStream {
-class wxInputStream {
  public:
   wxInputStream();
   virtual ~wxInputStream();
 
-  virtual wxInputStream& Read(void *buffer, size_t size) = 0;
+  // IO functions
+  virtual char Peek() = 0;
+  virtual char GetC();
+  virtual wxInputStream& Read(void *buffer, size_t size);
   wxInputStream& Read(wxOutputStream& stream_out);
 
-  virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart) = 0;
+  // Position functions
-  virtual off_t TellI() const = 0;
+  off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
+  off_t TellI() const;
 
-  virtual bool Eof() const = 0;
+  // State functions
-  virtual size_t LastRead() const = 0;
+  bool Eof() const { return m_eof; }
+  size_t LastRead() { return m_lastread; }
+  wxStreamBuffer *InputStreamBuffer() { return m_i_streambuf; }
 
+  // Operators
   wxInputStream& operator>>(wxOutputStream& out) { return Read(out); }
+  wxInputStream& operator>>(wxString& line);
+  wxInputStream& operator>>(char& c);
+  wxInputStream& operator>>(short& i);
+  wxInputStream& operator>>(long& i);
+  wxInputStream& operator>>(float& i);
+  wxInputStream& operator>>( __wxInputManip func) { return func(*this); }
+
+ protected:
+  friend class wxStreamBuffer;
+  friend class wxFilterInputStream;
+
+  wxInputStream(wxStreamBuffer *buffer);
+
+  virtual size_t DoRead(void *buffer, size_t size) = 0;
+  virtual off_t DoSeekInput(off_t pos, wxSeekMode mode) = 0;
+  virtual off_t DoTellInput() const = 0;
+
+ protected:
+  bool m_eof, m_i_destroybuf;
+  size_t m_lastread;
+  wxStreamBuffer *m_i_streambuf;
 };
 
-class wxOutputStream {
+class WXDLLEXPORT wxOutputStream {
  public:
   wxOutputStream();
   virtual ~wxOutputStream();
 
-  virtual wxOutputStream& Write(const void *buffer, size_t size) = 0;
+  virtual wxOutputStream& Write(const void *buffer, size_t size);
   wxOutputStream& Write(wxInputStream& stream_in);
 
-  virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart) = 0;
+  virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
-  virtual off_t TellO() const = 0;
+  virtual off_t TellO() const;
 
-  virtual bool Bad() const = 0;
+  virtual bool Bad() const { return m_bad; }
-  virtual size_t LastWrite() const = 0;
+  virtual size_t LastWrite() const { return m_lastwrite; }
+  wxStreamBuffer *OutputStreamBuffer() { return m_o_streambuf; }
 
-  virtual void Sync() {}
+  virtual void Sync();
+
+  wxOutputStream& operator<<(wxInputStream& out) { return Write(out); }
+  wxOutputStream& operator<<(const char *string);
+  wxOutputStream& operator<<(wxString& string);
+  wxOutputStream& operator<<(char c);
+  wxOutputStream& operator<<(short i);
+  wxOutputStream& operator<<(int i);
+  wxOutputStream& operator<<(long i);
+  wxOutputStream& operator<<(double f);
+
+  wxOutputStream& operator<<(float f) { return operator<<((double)f); }
+  wxOutputStream& operator<<(unsigned char c) { return operator<<((char)c); }
+  wxOutputStream& operator<<(unsigned short i) { return operator<<((short)i); }
+  wxOutputStream& operator<<(unsigned int i) { return operator<<((int)i); }
+  wxOutputStream& operator<<(unsigned long i) { return operator<<((long)i); }
+
+  wxOutputStream& operator<<( __wxOutputManip func) { return func(*this); }
+
+ protected:
+  friend class wxStreamBuffer;
+  friend class wxFilterOutputStream;
+
+  wxOutputStream(wxStreamBuffer *buffer);
+
+  virtual size_t DoWrite(const void *buffer, size_t size) = 0;
+  virtual off_t DoSeekOutput(off_t pos, wxSeekMode mode) = 0;
+  virtual off_t DoTellOutput() const = 0;
+
+ protected:
+  bool m_bad, m_o_destroybuf;
+  size_t m_lastwrite;
+  wxStreamBuffer *m_o_streambuf;
 };
 
 /*
  * "Filter" streams
  */
 
-class wxFilterInputStream: public wxInputStream {
+class WXDLLEXPORT wxFilterInputStream: public wxInputStream {
  public:
   wxFilterInputStream(wxInputStream& stream);
   virtual ~wxFilterInputStream();
 
-  virtual wxInputStream& Read(void *buffer, size_t size)
+  virtual char Peek() { return m_parent_i_stream->Peek(); }
-     { return m_parent_i_stream->Read(buffer, size); }
-  virtual off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart)
-     { return m_parent_i_stream->SeekI(pos, mode); }
-  virtual off_t TellI() const
-     { return m_parent_i_stream->TellI(); }
 
   virtual bool Eof() const { return m_parent_i_stream->Eof(); } 
   virtual size_t LastRead() const { return m_parent_i_stream->LastRead(); } 
 
+ protected:
+  virtual size_t DoRead(void *buffer, size_t size);
+  virtual off_t DoSeekInput(off_t pos, wxSeekMode mode);
+  virtual off_t DoTellInput() const;
+
  protected:
   wxInputStream *m_parent_i_stream;
 };
 
-class wxFilterOutputStream: public wxOutputStream {
+class WXDLLEXPORT wxFilterOutputStream: public wxOutputStream {
  public:
   wxFilterOutputStream(wxOutputStream& stream);
   virtual ~wxFilterOutputStream();
 
-  virtual wxOutputStream& Write(const void *buffer, size_t size)
-     { return m_parent_o_stream->Write(buffer, size); }
-  virtual off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart)
-     { return m_parent_o_stream->SeekO(pos, mode); }
-  virtual off_t TellO() const
-     { return m_parent_o_stream->TellO(); }
-
   virtual bool Bad() const { return m_parent_o_stream->Bad(); }
   virtual size_t LastWrite() const { return m_parent_o_stream->LastWrite(); }
 
+ protected:
+
+  // The forward is implicitely done by wxStreamBuffer.
+
+  virtual size_t DoWrite(const void *buffer, size_t size);
+  virtual off_t DoSeekOutput(off_t pos, wxSeekMode mode);
+  virtual off_t DoTellOutput() const;
+
  protected:
   wxOutputStream *m_parent_o_stream;
 };

include/wx/zstream.h

@@ -16,25 +16,23 @@
 #endif
 
 #include <wx/stream.h>
-#include "../../src/zlib/zlib.h"
+#include "zlib.h"
 
 class wxZlibInputStream: public wxFilterInputStream {
  public:
   wxZlibInputStream(wxInputStream& stream);
   virtual ~wxZlibInputStream();
 
-  wxInputStream& Read(void *buffer, size_t size);
-  off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart);
-  off_t TellI() const;
-
-  size_t LastRead() const { return m_lastread; }
   bool Eof() const;
 
  protected:
-  size_t m_lastread;
+  size_t DoRead(void *buffer, size_t size);
+  off_t DoSeekInput(off_t pos, wxSeekMode WXUNUSED(mode)) { return wxInvalidOffset; }
+  off_t DoTellInput() const { return wxInvalidOffset; }
+
+ protected:
   size_t m_z_size;
   unsigned char *m_z_buffer;
-  bool m_eof;
   struct z_stream_s m_inflate;
 };
 
@@ -43,18 +41,18 @@ class wxZlibOutputStream: public wxFilterOutputStream {
   wxZlibOutputStream(wxOutputStream& stream);
   virtual ~wxZlibOutputStream();
 
-  wxOutputStream& Write(const void *buffer, size_t size);
+  void Sync();
-  off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart);
-  off_t TellO() const;
 
-  size_t LastWrite() const { return m_lastwrite; }
   bool Bad() const;
 
  protected:
-  size_t m_lastwrite;
+  size_t DoWrite(const void *buffer, size_t size);
+  off_t DoSeekOutput(off_t pos, wxSeekMode WXUNUSED(mode)) { return wxInvalidOffset; }
+  off_t DoTellOutput() const { return wxInvalidOffset; }
+
+ protected:
   size_t m_z_size;
   unsigned char *m_z_buffer;
-  bool m_bad;
   struct z_stream_s m_deflate;
 };
 

src/Makefile.in

@@ -61,6 +61,7 @@ LIB_CPP_SRC=\
  common/mstream.cpp \
  common/zstream.cpp \
  common/datstrm.cpp \
+ common/objstrm.cpp \
 \
  gtk/app.cpp \
  gtk/bitmap.cpp \

src/common/file.cpp

@@ -143,7 +143,7 @@ bool wxFile::Create(const char *szFileName, bool bOverwrite, int access)
   int fd = open(szFileName, O_CREAT | (bOverwrite ? O_TRUNC : O_EXCL), access);
 
   if ( fd == -1 ) {
-    wxLogSysError(_("can't create file '%s'"), szFileName);
+    wxLogSysError("can't create file '%s'", szFileName);
     return FALSE;
   }
   else {
@@ -178,7 +178,7 @@ bool wxFile::Open(const char *szFileName, OpenMode mode, int access)
   int fd = open(szFileName, flags, access);
 
   if ( fd == -1 ) {
-    wxLogSysError(_("can't open file '%s'"), szFileName);
+    wxLogSysError("can't open file '%s'", szFileName);
     return FALSE;
   }
   else {
@@ -192,7 +192,7 @@ bool wxFile::Close()
 {
   if ( IsOpened() ) {
     if ( close(m_fd) == -1 ) {
-      wxLogSysError(_("can't close file descriptor %d"), m_fd);
+      wxLogSysError("can't close file descriptor %d", m_fd);
       m_fd = fd_invalid;
       return FALSE;
     }
@@ -214,8 +214,8 @@ off_t wxFile::Read(void *pBuf, off_t nCount)
 
   int iRc = ::read(m_fd, pBuf, nCount);
   if ( iRc == -1 ) {
-    wxLogSysError(_("can't read from file descriptor %d"), m_fd);
+    wxLogSysError("can't read from file descriptor %d", m_fd);
-    return ofsInvalid;
+    return wxInvalidOffset;
   }
   else
     return (uint)iRc;
@@ -228,22 +228,22 @@ uint wxFile::Write(const void *pBuf, uint nCount)
 
   int iRc = ::write(m_fd, pBuf, nCount);
   if ( iRc == -1 ) {
-    wxLogSysError(_("can't write to file descriptor %d"), m_fd);
+    wxLogSysError("can't write to file descriptor %d", m_fd);
     m_error = TRUE;
     return 0;
   }
   else
-    return (uint)iRc;
+    return iRc;
 }
 
 // flush
 bool wxFile::Flush()
 {
   if ( IsOpened() ) {
-// @@@ fsync() is not ANSI (BSDish)
+		// @@@ fsync() is not ANSI (BSDish)
 //    if ( fsync(m_fd) == -1 ) { // TODO
       if (TRUE) {
-      wxLogSysError(_("can't flush file descriptor %d"), m_fd);
+      wxLogSysError("can't flush file descriptor %d", m_fd);
       return FALSE;
     }
   }
@@ -280,8 +280,8 @@ off_t wxFile::Seek(off_t ofs, wxSeekMode mode)
 
   int iRc = lseek(m_fd, ofs, flag);
   if ( iRc == -1 ) {
-    wxLogSysError(_("can't seek on file descriptor %d"), m_fd);
+    wxLogSysError("can't seek on file descriptor %d", m_fd);
-    return ofsInvalid;
+    return wxInvalidOffset;
   }
   else
     return (off_t)iRc;
@@ -294,8 +294,8 @@ off_t wxFile::Tell() const
 
   int iRc = tell(m_fd);
   if ( iRc == -1 ) {
-    wxLogSysError(_("can't get seek position on file descriptor %d"), m_fd);
+    wxLogSysError("can't get seek position on file descriptor %d", m_fd);
-    return ofsInvalid;
+    return wxInvalidOffset;
   }
   else
     return (off_t)iRc;
@@ -327,8 +327,8 @@ off_t wxFile::Length() const
   #endif  //_MSC_VER
 
   if ( iRc == -1 ) {
-    wxLogSysError(_("can't find length of file on file descriptor %d"), m_fd);
+    wxLogSysError("can't find length of file on file descriptor %d", m_fd);
-    return ofsInvalid;
+    return wxInvalidOffset;
   }
   else
     return (off_t)iRc;
@@ -345,7 +345,7 @@ bool wxFile::Eof() const
     // @@ this doesn't work, of course, on unseekable file descriptors
     off_t ofsCur = Tell(),
           ofsMax = Length();
-    if ( ofsCur == ofsInvalid || ofsMax == ofsInvalid )
+    if ( ofsCur == wxInvalidOffset || ofsMax == wxInvalidOffset )
       iRc = -1;
     else
      iRc = ofsCur == ofsMax;
@@ -361,8 +361,8 @@ bool wxFile::Eof() const
       return FALSE;
 
     case -1:
-      wxLogSysError(_("can't determine if the end of file is reached on "
+      wxLogSysError("can't determine if the end of file is reached on "
-                      "descriptor %d"), m_fd);
+                    "descriptor %d", m_fd);
       break;
 
     default:
@@ -424,12 +424,12 @@ bool wxTempFile::Commit()
   m_file.Close();
 
   if ( wxFile::Exists(m_strName) && remove(m_strName) != 0 ) {
-    wxLogSysError(_("can't remove file '%s'"), m_strName.c_str());
+    wxLogSysError("can't remove file '%s'", m_strName.c_str());
     return FALSE;
   }
 
   if ( rename(m_strTemp, m_strName) != 0 ) {
-    wxLogSysError(_("can't commit changes to file '%s'"), m_strName.c_str());
+    wxLogSysError("can't commit changes to file '%s'", m_strName.c_str());
     return FALSE;
   }
 
@@ -440,5 +440,5 @@ void wxTempFile::Discard()
 {
   m_file.Close();
   if ( remove(m_strTemp) != 0 )
-    wxLogSysError(_("can't remove temporary file '%s'"), m_strTemp.c_str());
+    wxLogSysError("can't remove temporary file '%s'", m_strTemp.c_str());
 }

src/common/intl.cpp

@@ -10,7 +10,7 @@
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
-// declarations
+// declaration
 // ============================================================================
 
 // ----------------------------------------------------------------------------
@@ -28,19 +28,17 @@
 #pragma hdrstop
 #endif
 
-// wxWindows
+// standard headers
-#ifndef  WX_PRECOMP
+#include  <locale.h>
-  #include "wx/defs.h"
-  #include "wx/string.h"
-#endif //WX_PRECOMP
 
+// wxWindows
+#include "wx/defs.h"
+#include "wx/string.h"
 #include "wx/intl.h"
 #include "wx/file.h"
 #include "wx/log.h"
 #include "wx/utils.h"
 
-// standard headers
-#include <locale.h>
 #include <stdlib.h>
 
 // ----------------------------------------------------------------------------
@@ -55,23 +53,23 @@ const uint32 MSGCATALOG_MAGIC_SW = 0xde120495;
 #define MSGCATALOG_EXTENSION  ".mo"
 
 // ----------------------------------------------------------------------------
-// global functions (private to this module)
+// global functions
 // ----------------------------------------------------------------------------
 
 // suppress further error messages about missing translations
 // (if you don't have one catalog file, you wouldn't like to see the
 //  error message for each string in it, so normally it's given only
 //  once)
-static void wxSuppressTransErrors();
+void wxSuppressTransErrors();
 
 // restore the logging
-static void wxRestoreTransErrors();
+void wxRestoreTransErrors();
 
 // get the current state
-static bool wxIsLoggingTransErrors();
+bool wxIsLoggingTransErrors();
 
-// get the current locale object (@@ may be NULL!)
+// get the current locale object (## may be NULL!)
-static wxLocale *wxSetLocale(wxLocale *pLocale);
+extern wxLocale *wxSetLocale(wxLocale *pLocale);
 
 // ----------------------------------------------------------------------------
 // wxMsgCatalog corresponds to one disk-file message catalog.
@@ -199,8 +197,6 @@ wxMsgCatalog::~wxMsgCatalog()
   DELETEA(m_pszName); 
 }
 
-// a helper class which suppresses all translation error messages
-// from the moment of it's creation until it's destruction
 class NoTransErr
 {
   public:
@@ -211,15 +207,15 @@ class NoTransErr
 // open disk file and read in it's contents
 bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
 {
-  // search order (assume language 'lang') is
+  // search order (assume language 'foo') is
-  // 1) $LC_PATH/lang/LC_MESSAGES          (if LC_PATH set)
+  // 1) $LC_PATH/foo/LC_MESSAGES          (if LC_PATH set)
-  // 2) ./lang/LC_MESSAGES
+  // 2) ./foo/LC_MESSAGES
-  // 3) ./lang
+  // 3) ./foo
   // 4) . (Added by JACS)
   //
   // under UNIX we search also in:
-  // 5) /usr/share/locale/lang/LC_MESSAGES (Linux)
+  // 5) /usr/share/locale/foo/LC_MESSAGES (Linux)
-  // 6) /usr/lib/locale/lang/LC_MESSAGES   (Solaris)
+  // 6) /usr/lib/locale/foo/LC_MESSAGES   (Solaris)
   #define MSG_PATH FILE_SEP_PATH + "LC_MESSAGES" PATH_SEP
           
   wxString strPath("");
@@ -229,12 +225,12 @@ bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
   
   // NB: '<<' is unneeded between too literal strings: 
   //     they are concatenated at compile time
-  strPath << "./" << wxString(szDirPrefix) + MSG_PATH                 // (2)
+  strPath += "./" + wxString(szDirPrefix) + MSG_PATH                  // (2)
-          << "./" << szDirPrefix << FILE_SEP_PATH << PATH_SEP         // (3)
+          + "./" + szDirPrefix + FILE_SEP_PATH + PATH_SEP // (3)
-		      << "." << PATH_SEP                                          // (4)
+		  + "." + PATH_SEP
   #ifdef  __UNIX__
-             "/usr/share/locale/" << szDirPrefix << MSG_PATH          // (5)
+             "/usr/share/locale/" + szDirPrefix + MSG_PATH  // (5)
-             "/usr/lib/locale/"  << szDirPrefix << MSG_PATH           // (6)
+             "/usr/lib/locale/"  + szDirPrefix + MSG_PATH  // (6)
   #endif  //UNIX
           ;
   
@@ -247,41 +243,38 @@ bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
   // (we're using an object because we have several return paths)
   NoTransErr noTransErr;
 
-  wxLogVerbose(_("looking for catalog '%s' in path '%s'..."),
+  wxLogVerbose("looking for catalog '%s' in path '%s'.",
-               szName, strPath.c_str());
+             szName, strPath.c_str());
 
   wxString strFullName;
   if ( !wxFindFileInPath(&strFullName, strPath, strFile) ) {
-    wxLogWarning(_("catalog file for domain '%s' not found."), szName);
+    wxLogWarning("catalog file for domain '%s' not found.", szName);
     return FALSE;
   }
 
   // open file
-  wxLogVerbose(_("catalog '%s' found in '%s'."), szName, strFullName.c_str());
+  wxLogVerbose("using catalog '%s' from '%s'.",
+             szName, strFullName.c_str());
   
-  // declare these vars here because we're using goto further down
-  bool bValid;
-  off_t nSize;
-
   wxFile fileMsg(strFullName);
   if ( !fileMsg.IsOpened() )
-    goto error;
+    return FALSE;
 
   // get the file size
-  nSize = fileMsg.Length();
+  off_t nSize = fileMsg.Length();
-  if ( nSize == ofsInvalid )
+  if ( nSize == wxInvalidOffset )
-    goto error;
+    return FALSE;
 
   // read the whole file in memory
   m_pData = new uint8[nSize];
   if ( fileMsg.Read(m_pData, nSize) != nSize ) {
     DELETEA(m_pData);
     m_pData = NULL;
-    goto error;
+    return FALSE;
   }
     
   // examine header
-  bValid = (size_t)nSize > sizeof(wxMsgCatalogHeader);
+  bool bValid = (size_t)nSize > sizeof(wxMsgCatalogHeader);
   
   wxMsgCatalogHeader *pHeader;
   if ( bValid ) {
@@ -296,8 +289,7 @@ bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
   
   if ( !bValid ) {
     // it's either too short or has incorrect magic number
-    wxLogWarning(_("'%s' is not a valid message catalog."),
+    wxLogWarning("'%s' is not a valid message catalog.", strFullName.c_str());
-                 strFullName.c_str());
     
     DELETEA(m_pData);
     m_pData = NULL;
@@ -306,8 +298,10 @@ bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
       
   // initialize
   m_numStrings  = Swap(pHeader->numStrings);
-  m_pOrigTable  = (wxMsgTableEntry *)(m_pData + Swap(pHeader->ofsOrigTable));
+  m_pOrigTable  = (wxMsgTableEntry *)(m_pData + 
-  m_pTransTable = (wxMsgTableEntry *)(m_pData + Swap(pHeader->ofsTransTable));
+                   Swap(pHeader->ofsOrigTable));
+  m_pTransTable = (wxMsgTableEntry *)(m_pData + 
+                   Swap(pHeader->ofsTransTable));
 
   m_nHashSize   = Swap(pHeader->nHashSize);
   m_pHashTable  = (uint32 *)(m_pData + Swap(pHeader->ofsHashTable));
@@ -317,11 +311,6 @@ bool wxMsgCatalog::Load(const char *szDirPrefix, const char *szName)
 
   // everything is fine
   return TRUE;
-
-error:
-  wxLogError(_("error opening message catalog '%s', not loaded."),
-             strFullName.c_str());
-  return FALSE;
 }
 
 // search for a string
@@ -386,12 +375,12 @@ wxLocale::wxLocale(const char *szName,
     szLocale = szName;
   m_pszOldLocale = setlocale(LC_ALL, szLocale);
   if ( m_pszOldLocale == NULL )
-    wxLogError(_("locale '%s' can not be set."), szLocale);
+    wxLogError("locale '%s' can not be set.", szLocale);
 
   // the short name will be used to look for catalog files as well,
   // so we need something here
   if ( m_strShort.IsEmpty() ) {
-    // @@@@ I don't know how these 2 letter abbreviations are formed,
+    // #### I don't know how these 2 letter abbreviations are formed,
     //      this wild guess is almost surely wrong
     m_strShort = wxToLower(szLocale[0]) + wxToLower(szLocale[1]);
   }
@@ -453,12 +442,11 @@ const char *wxLocale::GetString(const char *szOrigString,
       wxSuppressTransErrors();
       
       if ( szDomain != NULL )
-        wxLogWarning(_("string '%s' not found in domain '%s'"
+        wxLogWarning("string '%s' not found in domain '%s' for locale '%s'.",
-                       " for locale '%s'."),
+                    szOrigString, szDomain, m_strLocale.c_str());
-                     szOrigString, szDomain, m_strLocale.c_str());
       else
-        wxLogWarning(_("string '%s' not found in locale '%s'."),
+        wxLogWarning("string '%s' not found in locale '%s'.",
-                     szOrigString, m_strLocale.c_str());
+                   szOrigString, m_strLocale.c_str());
     }
 
     return szOrigString;
@@ -537,6 +525,11 @@ bool wxIsLoggingTransErrors()
 // the current locale object
 wxLocale *g_pLocale = NULL;
 
+wxLocale *wxGetLocale()
+{
+	return g_pLocale;
+}
+
 wxLocale *wxSetLocale(wxLocale *pLocale)
 {
 	wxLocale *pOld = g_pLocale;

src/common/object.cpp

@@ -20,7 +20,10 @@
 #pragma hdrstop
 #endif
 
+#ifndef WX_PRECOMP
 #include "wx/hash.h"
+#include "wx/objstrm.h"
+#endif
 
 #include <string.h>
 #include <assert.h>
@@ -114,36 +117,6 @@ void wxObject::operator delete[] (void * buf)
  * Class info: provides run-time class type information.
  */
 
-#ifdef USE_STORABLE_CLASSES
-
-wxClassInfo::wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn fn,
-     wxStorableConstructorFn stoFn )
-{
-  className = cName;
-  baseClassName1 = baseName1;
-  baseClassName2 = baseName2;
-
-  objectSize = sz;
-  objectConstructor = fn;
-  storableConstructor = stoFn;
-  
-  next = first;
-  first = this;
-
-  baseInfo1 = NULL;
-  baseInfo2 = NULL;
-}
-   
-wxObject* wxClassInfo::CreateObject( istream &stream, char *data )
-{
-  if (storableConstructor)
-    return (wxObject *)(*storableConstructor)( stream, data );
-  else
-    return NULL;
-}
-
-#else
-  
 wxClassInfo::wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz, wxObjectConstructorFn constr)
 {
   className = cName;
@@ -160,8 +133,6 @@ wxClassInfo::wxClassInfo(char *cName, char *baseName1, char *baseName2, int sz,
   baseInfo2 = NULL;
 }
 
-#endif
-
 wxObject *wxClassInfo::CreateObject(void)
 {
   if (objectConstructor)
@@ -250,16 +221,10 @@ wxObject *wxCreateDynamicObject(char *name)
 
 #ifdef USE_STORABLE_CLASSES
 
-wxObject* wxCreateStoredObject( char *name, istream &stream, char *data )
+wxObject* wxCreateStoredObject( wxInputStream &stream )
 {
-  wxClassInfo *info = wxClassInfo::first;
+  wxObjectInputStream obj_s(stream);
-  while (info)
+  return obj_s.LoadObject();
-  {
-    if (info->className && strcmp(info->className, name) == 0)
-      return info->CreateObject( stream, data );
-    info = info->next;
-  }
-  return NULL;
 };
 
 #endif

src/common/stream.cpp

@@ -21,6 +21,10 @@
 #pragma hdrstop
 #endif
 
+// ----------------------------------------------------------------------------
+// wxInputStream
+// ----------------------------------------------------------------------------
+
 wxInputStream::wxInputStream()
 {
 }
@@ -44,6 +48,48 @@ wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
   return *this;
 }
 
+int wxInputStream::Scanf(const wxString& format, ...)
+{
+  va_list params;
+
+  va_start(params, format);
+  va_end(params);
+}
+
+wxInputStream& wxInputStream::operator>>(wxString& line)
+{
+  wxDataInputStream s(*this);
+
+  line = s.ReadLine();
+  return *this;
+}
+
+wxInputStream& wxInputStream::operator>>(char& c)
+{
+  c = GetC();
+}
+
+wxInputStream& wxInputStream::operator>>(short& i)
+{
+  Scanf("%i", &i);
+  return *this;
+}
+
+wxInputStream& wxInputStream::operator>>(long& i)
+{
+  Scanf("%l", &i);
+  return *this;
+}
+
+wxInputStream& wxInputStream::operator>>(float& f)
+{
+  Scanf("%f", &f);
+  return *this;
+}
+
+// ----------------------------------------------------------------------------
+// wxOutputStream
+// ----------------------------------------------------------------------------
 wxOutputStream::wxOutputStream()
 {
 }
@@ -58,6 +104,9 @@ wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
    return *this;
 }
 
+// ----------------------------------------------------------------------------
+// wxFilterInputStream
+// ----------------------------------------------------------------------------
 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
   : wxInputStream()
 {
@@ -68,6 +117,9 @@ wxFilterInputStream::~wxFilterInputStream()
 {
 }
 
+// ----------------------------------------------------------------------------
+// wxFilterOutputStream
+// ----------------------------------------------------------------------------
 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
   : wxOutputStream()
 {

src/common/textfile.cpp

@@ -131,7 +131,7 @@ wxTextFile::Type wxTextFile::GuessType() const
   // interpret the results (@@ far from being even 50% fool proof)
   if ( nDos + nUnix + nMac == 0 ) {
     // no newlines at all
-    wxLogWarning(_("'%s' is probably a binary file."), m_strFile.c_str());
+    wxLogWarning("'%s' is probably a binary file.", m_strFile.c_str());
   }
   else {
     #define   GREATER_OF(t1, t2) n##t1 == n##t2 ? typeDefault               \
@@ -164,7 +164,7 @@ bool wxTextFile::Read()
   int n, nRead;
   while ( !m_file.Eof() ) {
     nRead = m_file.Read(buf, WXSIZEOF(buf));
-    if ( nRead == ofsInvalid ) {
+    if ( nRead == wxInvalidOffset ) {
       // read error (error message already given in wxFile::Read)
       m_file.Close();
       return FALSE;
@@ -224,7 +224,7 @@ bool wxTextFile::Write(Type typeNew)
   wxTempFile fileTmp(m_strFile);
 
   if ( !fileTmp.IsOpened() ) {
-    wxLogError(_("can't write file '%s' to disk."), m_strFile.c_str());
+    wxLogError("can't write file '%s' to disk.", m_strFile.c_str());
     return FALSE;
   }