Improved cached macro performance.

Author: c-lipka

source/base/fileinputoutput.cpp

@@ -383,21 +383,36 @@ POV_LONG GetFileLength(const Path& p)
     return result;
 }
 
-bool IMemStream::read(void *buffer, size_t count)
+bool IMemStream::read(void *buffer, size_t maxCount)
 {
-    if (!fail)
+    size_t count = 0;
+
+    if (fail)
+        return false;
+
+    unsigned char* p = reinterpret_cast<unsigned char*>(buffer);
+
+    if (maxCount == 0)
+        return true;
+
+    // read from unget buffer first
+    if (mUngetBuffer != EOF)
     {
-        if ((count <= size) && (pos <= size-count))
-        {
-            memcpy(buffer,&start[pos],count);
-            pos += count;
-        }
-        else
-        {
-            fail = true;
-        }
+        *(p++) = (unsigned char)mUngetBuffer;
+        mUngetBuffer = EOF;
+        if (++count == maxCount)
+            return true;
     }
-    return !fail;
+
+    size_t copyFromBuffer = min(maxCount-count, size-pos);
+    memcpy(p, &(start[pos]), copyFromBuffer);
+    count += copyFromBuffer;
+    pos += copyFromBuffer;
+    if (count == maxCount)
+        return true;
+
+    fail = true;
+    return false;
 }
 
 int IMemStream::Read_Byte()
@@ -407,6 +422,11 @@ int IMemStream::Read_Byte()
     {
         v = EOF;
     }
+    else if (mUngetBuffer != EOF)
+    {
+        v = mUngetBuffer;
+        mUngetBuffer = EOF;
+    }
     else
     {
         if (pos < size)
@@ -419,14 +439,12 @@ int IMemStream::Read_Byte()
 
 bool IMemStream::UnRead_Byte(int c)
 {
-    if (!fail)
-    {
-        if (pos > 0)
-            pos--;
-        else
-            fail = true;
-    }
-    return !fail;
+    if (fail)
+        return false;
+
+    mUngetBuffer = c;
+
+    return true;
 }
 
 bool IMemStream::getline(char *s,size_t buflen)
@@ -438,13 +456,19 @@ bool IMemStream::getline(char *s,size_t buflen)
 
 POV_LONG IMemStream::tellg() const
 {
-    return formalStart + pos;
+    size_t physicalPos = pos;
+    if (mUngetBuffer != EOF)
+        ++physicalPos;
+    return formalStart + physicalPos;
 }
 
 bool IMemStream::seekg(POV_LONG posi, unsigned int whence)
 {
     if(!fail)
     {
+        // Any seek operation renders the unget buffer's content obsolete.
+        mUngetBuffer = EOF;
+
         switch(whence)
         {
             case seek_set:

source/base/fileinputoutput.h

@@ -185,6 +185,7 @@ class IMemStream : public IStream
         size_t pos;
         POV_LONG formalStart;
         const unsigned char * start;
+        int mUngetBuffer;
 };
 
 class OStream : public IOBase

source/base/textstream.cpp

@@ -49,7 +49,16 @@
 namespace pov_base
 {
 
-ITextStream::ITextStream(const UCS2 *sname, unsigned int stype)
+ITextStream::ITextStream() :
+    lineno(1)
+{
+}
+
+ITextStream::~ITextStream()
+{
+}
+
+IBufferedTextStream::IBufferedTextStream(const UCS2 *sname, unsigned int stype)
 {
     if(sname == NULL)
         throw POV_EXCEPTION_CODE(kParamErr);
@@ -59,7 +68,6 @@ ITextStream::ITextStream(const UCS2 *sname, unsigned int stype)
         throw POV_EXCEPTION(kCannotOpenFileErr, string("Cannot open file '") + UCS2toASCIIString(sname) + "' for input.");
 
     filename = UCS2String(sname);
-    lineno = 1;
     bufferoffset = 0;
     maxbufferoffset = 0;
     filelength = 0;
@@ -73,7 +81,7 @@ ITextStream::ITextStream(const UCS2 *sname, unsigned int stype)
     RefillBuffer();
 }
 
-ITextStream::ITextStream(const UCS2 *sname, IStream *sstream, POV_LONG initialLine)
+IBufferedTextStream::IBufferedTextStream(const UCS2 *sname, IStream *sstream, POV_LONG initialLine)
 {
     if(sname == NULL)
         throw POV_EXCEPTION_CODE(kParamErr);
@@ -96,13 +104,13 @@ ITextStream::ITextStream(const UCS2 *sname, IStream *sstream, POV_LONG initialLi
     RefillBuffer();
 }
 
-ITextStream::~ITextStream()
+IBufferedTextStream::~IBufferedTextStream()
 {
     delete stream;
     stream = NULL;
 }
 
-int ITextStream::getchar()
+int IBufferedTextStream::getchar()
 {
     int chr = 0;
 
@@ -146,27 +154,28 @@ int ITextStream::getchar()
     return chr;
 }
 
-void ITextStream::ungetchar(int chr)
+void IBufferedTextStream::ungetchar(int chr)
 {
     ungetbuffer = chr;
     if(chr == '\n')
         lineno--;
 }
 
-bool ITextStream::eof() const
+bool IBufferedTextStream::eof() const
 {
     if(ungetbuffer != EOF)
         return false;
     if(bufferoffset >= maxbufferoffset)
+        // NB this relies on RefillBuffer being called by each read operation that exhausts the buffer
         return true;
     return stream->eof();
 }
 
-bool ITextStream::seekg(ITextStream::FilePos fp)
+bool IBufferedTextStream::seekg(ITextStream::FilePos fp)
 {
     bool result = true;
 
-    if((fp.offset < curpos) && ((curpos - fp.offset) < maxbufferoffset))
+    if((fp.offset < curpos) && ((curpos - fp.offset) <= maxbufferoffset))
     {
         bufferoffset = maxbufferoffset - (curpos - fp.offset);
         lineno = fp.lineno;
@@ -194,7 +203,7 @@ bool ITextStream::seekg(ITextStream::FilePos fp)
     return result;
 }
 
-ITextStream::FilePos ITextStream::tellg() const
+ITextStream::FilePos IBufferedTextStream::tellg() const
 {
     FilePos fp;
 
@@ -207,7 +216,7 @@ ITextStream::FilePos ITextStream::tellg() const
     return fp;
 }
 
-bool ITextStream::ReadRaw(unsigned char* buf, size_t size)
+bool IBufferedTextStream::ReadRaw(unsigned char* buf, size_t size)
 {
     unsigned char* p = buf;
     size_t remain = size;
@@ -251,7 +260,7 @@ bool ITextStream::ReadRaw(unsigned char* buf, size_t size)
     return false;
 }
 
-void ITextStream::RefillBuffer()
+void IBufferedTextStream::RefillBuffer()
 {
     if(bufferoffset < maxbufferoffset)
     {
@@ -269,6 +278,148 @@ void ITextStream::RefillBuffer()
         curpos = stream->tellg() ;
 }
 
+IMemTextStream::IMemTextStream(const UCS2 *formalName, unsigned char* data, size_t size, const FilePos& formalStart)
+{
+    if(formalName == NULL)
+        throw POV_EXCEPTION_CODE(kParamErr);
+    if(data == NULL)
+        throw POV_EXCEPTION_CODE(kParamErr);
+
+    buffer = data;
+    filename = UCS2String(formalName);
+    lineno = formalStart.lineno;
+    bufferoffset = 0;
+    maxbufferoffset = size;
+    ungetbuffer = EOF;
+    mFormalStart = formalStart.offset;
+    fail = false;
+}
+
+IMemTextStream::~IMemTextStream()
+{
+}
+
+int IMemTextStream::getchar()
+{
+    int chr = 0;
+
+    if(ungetbuffer != EOF)
+    {
+        chr = ungetbuffer;
+        ungetbuffer = EOF;
+    }
+    else
+    {
+        if(bufferoffset >= maxbufferoffset)
+        {
+            chr = EOF;
+            fail = true;
+        }
+        else
+        {
+            chr = buffer[bufferoffset];
+            bufferoffset++;
+        }
+    }
+
+    if(chr == 10)
+    {
+        if((bufferoffset < maxbufferoffset) && (buffer[bufferoffset] == 13))
+            bufferoffset++;
+        chr = '\n';
+        lineno++;
+    }
+    else if(chr == 13)
+    {
+        if((bufferoffset < maxbufferoffset) && (buffer[bufferoffset] == 10))
+            bufferoffset++;
+        chr = '\n';
+        lineno++;
+    }
+
+    return chr;
+}
+
+void IMemTextStream::ungetchar(int chr)
+{
+    ungetbuffer = chr;
+    if(chr == '\n')
+        lineno--;
+}
+
+bool IMemTextStream::eof() const
+{
+    if(ungetbuffer != EOF)
+        return false;
+    return fail;
+}
+
+bool IMemTextStream::seekg(ITextStream::FilePos fp)
+{
+    fail = false;
+
+    if((fp.offset < mFormalStart + maxbufferoffset) && (mFormalStart <= fp.offset))
+    {
+        bufferoffset = fp.offset - mFormalStart;
+        lineno = fp.lineno;
+        ungetbuffer = EOF;
+    }
+    else
+    {
+        fail = true;
+    }
+
+    return !fail;
+}
+
+ITextStream::FilePos IMemTextStream::tellg() const
+{
+    FilePos fp;
+
+    fp.lineno = lineno;
+    fp.offset = mFormalStart + bufferoffset;
+
+    if(ungetbuffer != EOF)
+        fp.offset--;
+
+    return fp;
+}
+
+bool IMemTextStream::ReadRaw(unsigned char* buf, size_t size)
+{
+    if (fail)
+        return false;
+
+    unsigned char* p = buf;
+    size_t remain = size;
+
+    if (remain == 0)
+        return true;
+
+    // read from unget buffer first
+    if (ungetbuffer != EOF)
+    {
+        *(p++) = (unsigned char)ungetbuffer;
+        ungetbuffer = EOF;
+        if (--remain == 0)
+            return true;
+    }
+
+    // next read from the regular buffer
+    if (bufferoffset < maxbufferoffset)
+    {
+        size_t copyFromBuffer = min(remain, size_t(maxbufferoffset - bufferoffset));
+        memcpy(p, &(buffer[bufferoffset]), copyFromBuffer);
+        remain -= copyFromBuffer;
+        bufferoffset += copyFromBuffer;
+        p += copyFromBuffer;
+        if (remain == 0)
+            return true;
+    }
+
+    return false;
+}
+
 OTextStream::OTextStream(const UCS2 *sname, unsigned int stype, bool append)
 {
     if(sname == NULL)