use streamsize and char_type, export the C++ API via the class not its methods

diff --git a/README b/README
index 7b4cf58..0c6e6b6 100755 (executable)
--- a/README
+++ b/README
@@ -1,7 +1,7 @@
 FastCGI Developer's Kit README
 ------------------------------
 
-    $Id: README,v 1.16 2002/02/23 21:22:01 robs Exp $
+    $Id: README,v 1.17 2002/02/24 20:12:21 robs Exp $
     Copyright (c) 1996 Open Market, Inc.
     See the file "LICENSE.TERMS" for information on usage and redistribution
     of this file, and for a DISCLAIMER OF ALL WARRANTIES.
@@ -31,6 +31,7 @@ on http://fastcgi.com/.
 
 2.2.3
 -----
+ *) Use streamsize and char_type in the C++ API.
 
  *) [WIN32] Eliminate the (partial and broken) use of OverlappedIO - this 
     was causing a loose spin in acceptNamedPipe().

diff --git a/include/fcgio.h b/include/fcgio.h
index db1d85a..2aa5b62 100644 (file)
--- a/include/fcgio.h
+++ b/include/fcgio.h
@@ -1,7 +1,7 @@
 //
 // Provides support for FastCGI via C++ iostreams.
 //
-// $Id: fcgio.h,v 1.13 2001/12/04 00:22:04 robs Exp $
+// $Id: fcgio.h,v 1.14 2002/02/24 20:12:23 robs Exp $
 //
 // This work is based on routines written by George Feinberg. They
 // have been mostly re-written and extensively changed by
@@ -30,7 +30,7 @@
 #ifndef FCGIO_H
 #define FCGIO_H
 
-#include <iostream.h>
+#include <iostream>
 
 #include "fcgiapp.h"
 
@@ -42,10 +42,14 @@
 #endif
 #endif
 
+#if ! HAVE_STREAMBUF_CHAR_TYPE
+typedef char char_type;
+#endif
+
 /*
  *  fcgi_streambuf
  */
-class fcgi_streambuf : public streambuf
+class DLLAPI fcgi_streambuf : public std::streambuf
 {
 public:
 
@@ -54,50 +58,50 @@ public:
     // assigned, I/O is a bit less effecient and output streams will
     // have to be flushed (or the streambuf destroyed) before the next 
     // call to "accept".
-    DLLAPI fcgi_streambuf(FCGX_Stream * fcgx, char * buf, int len);
+    fcgi_streambuf(FCGX_Stream * fcgx, char * buf, int len);
     
-    DLLAPI fcgi_streambuf(char * buf, int len);
+    fcgi_streambuf(char_type * buf, std::streamsize len);
     
-    DLLAPI fcgi_streambuf(FCGX_Stream * fcgx = 0);
+    fcgi_streambuf(FCGX_Stream * fcgx = 0);
 
-    DLLAPI ~fcgi_streambuf(void);
+    ~fcgi_streambuf(void);
 
-    DLLAPI int attach(FCGX_Stream * fcgx);
+    int attach(FCGX_Stream * fcgx);
 
 protected:
 
     // Consume the put area (if buffered) and c (if c is not EOF).
-    DLLAPI virtual int overflow(int);
+    virtual int overflow(int);
 
     // Flush the put area (if buffered) and the FCGX buffer to the client.
-    DLLAPI virtual int sync();
+    virtual int sync();
 
     // Remove and return the current character.
-    DLLAPI virtual int uflow();
+    virtual int uflow();
 
     // Fill the get area (if buffered) and return the current character.
-    DLLAPI virtual int underflow();
+    virtual int underflow();
 
     // Use a buffer.  The only reasons that a buffer would be useful is
     // to support the use of the unget()/putback() or seek() methods.  Using
     // a buffer will result in less efficient I/O.  Note: the underlying
     // FastCGI library (FCGX) maintains its own input and output buffers.  
-    DLLAPI virtual streambuf * setbuf(char * buf, int len);
+    virtual std::streambuf * setbuf(char_type * buf, std::streamsize len);
 
-    DLLAPI virtual int xsgetn(char * s, int n);
-    DLLAPI virtual int xsputn(const char * s, int n);
+    virtual int xsgetn(char_type * s, std::streamsize n);
+    virtual int xsputn(const char_type * s, std::streamsize n);
 
 private:
 
     FCGX_Stream * fcgx;
 
     // buf is just handy to have around
-    char * buf;
+    char_type * buf;
 
     // this isn't kept by the base class
-    int bufsize;
+    std::streamsize bufsize;
     
-    void init(FCGX_Stream * fcgx, char * buf, int bufsize);
+    void init(FCGX_Stream * fcgx, char_type * buf, std::streamsize bufsize);
 
     void reset(void);
 };
@@ -105,18 +109,18 @@ private:
 /*
  *  fcgi_istream - deprecated
  */
-class fcgi_istream : public istream
+class DLLAPI fcgi_istream : public std::istream
 {
 public:
 
     // deprecated
-    DLLAPI fcgi_istream(FCGX_Stream * fcgx = 0);
+    fcgi_istream(FCGX_Stream * fcgx = 0);
     
     // deprecated
-    DLLAPI ~fcgi_istream(void) {}
+    ~fcgi_istream(void) {}
 
     // deprecated
-    DLLAPI virtual void attach(FCGX_Stream * fcgx);
+    virtual void attach(FCGX_Stream * fcgx);
 
 private:
 
@@ -126,18 +130,18 @@ private:
 /*
  *  fcgi_ostream - deprecated
  */
-class fcgi_ostream : public ostream
+class DLLAPI fcgi_ostream : public std::ostream
 {
 public:
     
     // deprecated
-    DLLAPI fcgi_ostream(FCGX_Stream * fcgx = 0);
+    fcgi_ostream(FCGX_Stream * fcgx = 0);
     
     // deprecated
-    DLLAPI ~fcgi_ostream(void) {}
+    ~fcgi_ostream(void) {}
 
     // deprecated
-    DLLAPI virtual void attach(FCGX_Stream *fcgx);
+    virtual void attach(FCGX_Stream *fcgx);
 
 private:
 

diff --git a/libfcgi/fcgio.cpp b/libfcgi/fcgio.cpp
index 0eb6e87..95e28ca 100644 (file)
--- a/libfcgi/fcgio.cpp
+++ b/libfcgi/fcgio.cpp
@@ -1,5 +1,5 @@
 //
-// $Id: fcgio.cpp,v 1.12 2001/12/04 00:22:06 robs Exp $
+// $Id: fcgio.cpp,v 1.13 2002/02/24 20:12:22 robs Exp $
 //
 // Allows you communicate with FastCGI streams using C++ iostreams
 //
@@ -22,14 +22,20 @@
 #define DLLAPI  __declspec(dllexport)
 #endif
 
+#include <limits.h>
 #include "fcgio.h"
 
+using std::streambuf;
+using std::istream;
+using std::ostream;
+using std::streamsize;
+
 fcgi_streambuf::fcgi_streambuf(FCGX_Stream * fs, char * b, int bs)
 {
     init(fs, b, bs);
 }
     
-fcgi_streambuf::fcgi_streambuf(char * b, int bs)
+fcgi_streambuf::fcgi_streambuf(char_type * b, streamsize bs)
 {
     init(0, b, bs);
 }
@@ -45,7 +51,7 @@ fcgi_streambuf::~fcgi_streambuf(void)
     // FCGX_Finish()/FCGX_Accept() will flush and close
 }
 
-void fcgi_streambuf::init(FCGX_Stream * fs, char * b, int bs)
+void fcgi_streambuf::init(FCGX_Stream * fs, char_type * b, streamsize bs)
 {
     this->fcgx = fs;
     this->buf = 0;
@@ -118,7 +124,7 @@ void fcgi_streambuf::reset(void)
     setp(this->buf, this->buf + this->bufsize);
 }
 
-streambuf * fcgi_streambuf::setbuf(char * b, int bs)
+std::streambuf * fcgi_streambuf::setbuf(char_type * b, streamsize bs)
 {
     // XXX support moving data from an old buffer
     if (this->bufsize) return 0;
@@ -146,18 +152,20 @@ int fcgi_streambuf::attach(FCGX_Stream * fs)
     return 0;
 }
 
-int fcgi_streambuf::xsgetn(char * s, int n) 
+streamsize fcgi_streambuf::xsgetn(char_type * s, streamsize n) 
 {
+    if (n > INT_MAX) return 0;
     return (this->bufsize) 
         ? streambuf::xsgetn(s, n) 
-        : FCGX_GetStr(s, n, this->fcgx);
+        : (streamsize) FCGX_GetStr((char *) s, (int) n, this->fcgx);
 }
    
-int fcgi_streambuf::xsputn(const char * s, int n) 
+streamsize fcgi_streambuf::xsputn(const char_type * s, streamsize n) 
 {
+    if (n > INT_MAX) return 0;
     return (this->bufsize) 
         ? streambuf::xsputn(s, n) 
-        : FCGX_PutStr(s, n, this->fcgx);
+        : (streamsize) FCGX_PutStr((char *) s, (int) n, this->fcgx);
 }
 
 // deprecated