Re-enable macro caching.

Author: c-lipka

source/base/fileinputoutput.cpp

@@ -511,37 +511,35 @@ POV_OFF_T IMemStream::tellg() const
 
 bool IMemStream::seekg(POV_OFF_T posi, unsigned int whence)
 {
-    if(!fail)
-    {
-        // Any seek operation renders the unget buffer's content obsolete.
-        mUngetBuffer = EOF;
+    // Any seek operation renders the end-of-file status and unget buffer's content obsolete.
+    fail = false;
+    mUngetBuffer = EOF;
 
-        switch(whence)
-        {
-            case seek_set:
-                if (posi < formalStart)
-                    fail = true;
-                else if (posi - formalStart <= size)
-                    pos = posi - formalStart;
-                else
-                    fail = true;
-                break;
-            case seek_cur:
-                if ((posi <= size) && (pos <= size-posi))
-                    pos += posi;
-                else
-                    fail = true;
-                break;
-            case seek_end:
-                if (posi <= size)
-                    pos = size - posi;
-                else
-                    fail = true;
-                break;
-            default:
-                POV_ASSERT(false);
-                break;
-        }
+    switch(whence)
+    {
+        case seek_set:
+            if (posi < formalStart)
+                fail = true;
+            else if (posi - formalStart <= size)
+                pos = posi - formalStart;
+            else
+                fail = true;
+            break;
+        case seek_cur:
+            if ((posi <= size) && (pos <= size-posi))
+                pos += posi;
+            else
+                fail = true;
+            break;
+        case seek_end:
+            if (posi <= size)
+                pos = size - posi;
+            else
+                fail = true;
+            break;
+        default:
+            POV_ASSERT(false);
+            break;
     }
     return !fail;
 }

source/parser/parser_tokenizer.cpp

@@ -1321,24 +1321,19 @@ void Parser::Parse_Directive(int After_Hash)
                             PMac->endPosition = hashPosition;
                             POV_OFF_T macroLength = mToken.raw.lexeme.position - PMac->source;
                             /// @todo Re-enable cached macros.
-#if 0
                             if (macroLength <= MaxCachedMacroSize)
                             {
                                 PMac->CacheSize = macroLength;
                                 PMac->Cache = new unsigned char[PMac->CacheSize];
-                                if (PMac->Cache)
+                                RawTokenizer::HotBookmark pos = mTokenizer.GetHotBookmark();
+                                mTokenizer.GoToBookmark(PMac->source);
+                                if (!mTokenizer.GetRaw(PMac->Cache, PMac->CacheSize))
                                 {
-                                    mTokenizer.GoToBookmark(PMac->source);
-                                    Input_File->inFile->seekg(PMac->Macro_File_Pos);
-                                    if (!Input_File->inFile->ReadRaw(PMac->Cache, PMac->CacheSize))
-                                    {
-                                        delete[] PMac->Cache;
-                                        PMac->Cache = nullptr;
-                                    }
-                                    Input_File->inFile->seekg(pos);
+                                    delete[] PMac->Cache;
+                                    PMac->Cache = nullptr;
                                 }
+                                mTokenizer.GoToBookmark(pos);
                             }
-#endif
                         }
                     }
                     Cond_Stack.pop_back();
@@ -2580,7 +2575,6 @@ void Parser::Invoke_Macro()
         UCS2String ign;
         /* Not in same file */
         Cond_Stack.back().Macro_Same_Flag = false;
-        Cond_Stack.back().returnToBookmark = mTokenizer.GetHotBookmark();
         Got_EOF=false;
         POV_PARSER_ASSERT(!readingExternalFile);
         shared_ptr<IStream> is;
@@ -2604,7 +2598,8 @@ void Parser::Invoke_Macro()
     Got_EOF=false;
     if (!mTokenizer.GoToBookmark(PMac->source))
     {
-        Error("Unable to file seek in macro.");
+        ErrorInfo(mToken, "Invoking macro from here.");
+        Error(PMac->source, "Unable to file seek in macro invocation.");
     }
 
     mToken.sourceFile = mTokenizer.GetSource();
@@ -2621,17 +2616,16 @@ void Parser::Return_From_Macro()
 {
     Check_Macro_Vers();
 
-    if (!Cond_Stack.back().Macro_Same_Flag)
-    {
-        POV_PARSER_ASSERT(!readingExternalFile);
-        mTokenizer.SetInputStream(Cond_Stack.back().returnToBookmark.pSource);
-        mToken.sourceFile = mTokenizer.GetSource();
-    }
+    POV_PARSER_ASSERT(!readingExternalFile);
 
     Got_EOF=false;
 
     if (!mTokenizer.GoToBookmark(Cond_Stack.back().returnToBookmark))
-        Error("Unable to file seek in return from macro.");
+    {
+        ErrorInfo(mToken, "Returning from macro.");
+        Error(Cond_Stack.back().returnToBookmark, "Unable to file seek in return from macro.");
+    }
+    mToken.sourceFile = mTokenizer.GetSource();
 
     // Always destroy macro locals
     Destroy_Table(Table_Index--);

source/parser/rawtokenizer.cpp

@@ -369,6 +369,13 @@ TokenId pov_parser::RawTokenizer::GetExpressionId(TokenId tokenId)
 
 //------------------------------------------------------------------------------
 
+bool RawTokenizer::GetRaw(unsigned char* buffer, size_t size)
+{
+    return mScanner.GetRaw(buffer, size);
+}
+
+//------------------------------------------------------------------------------
+
 pov_parser::ConstSourcePtr RawTokenizer::GetSource() const
 {
     return mScanner.GetSource();

source/parser/rawtokenizer.h

@@ -169,6 +169,13 @@ class RawTokenizer
     /// Advance to the next `#` token in the input stream.
     bool GetNextDirective(RawToken& token);
 
+    /// Read raw data.
+    /// @deprecated
+    ///     This method is only intended as a temporary measure to implement
+    ///     binary-level macro caching, to provide a reference for performance
+    ///     testing of the envisioned token-level macro caching.
+    bool GetRaw(unsigned char* buffer, size_t size);
+
     /// Get current source for comparison.
     ConstSourcePtr GetSource() const;
 

source/parser/scanner.cpp

@@ -744,6 +744,38 @@ bool Scanner::EatNextBlockComment()
 
 //------------------------------------------------------------------------------
 
+bool Scanner::GetRaw(unsigned char* buffer, size_t size)
+{
+    POV_PARSER_ASSERT(!mEndOfStream);
+
+    unsigned char* pBufPos = buffer;
+    size_t sizeToCopy = size;
+    size_t sizeInBuffer = (mpBufferEnd - mpNextChar);
+    while (!mEndOfStream && (sizeToCopy >= sizeInBuffer))
+    {
+        memcpy(pBufPos, mpNextChar, sizeInBuffer);
+        pBufPos += sizeInBuffer;
+        mpNextChar += sizeInBuffer;
+        POV_PARSER_ASSERT(mpNextChar == mpBufferEnd);
+        RefillBuffer();
+        sizeToCopy -= sizeInBuffer;
+        sizeInBuffer = (mpBufferEnd - mpNextChar);
+    }
+
+    if (!mEndOfStream && (sizeToCopy > 0))
+    {
+        POV_PARSER_ASSERT(sizeToCopy < sizeInBuffer);
+        memcpy(pBufPos, mpNextChar, sizeToCopy);
+        pBufPos += sizeToCopy;
+        mpNextChar += sizeToCopy;
+        sizeToCopy -= sizeToCopy;
+    }
+
+    return (sizeToCopy == 0);
+}
+
+//------------------------------------------------------------------------------
+
 ConstSourcePtr Scanner::GetSource() const
 {
     return mpSource;

source/parser/scanner.h

@@ -159,6 +159,13 @@ class Scanner
     /// Advance to the next `#` lexeme in the input stream.
     bool GetNextDirective(Lexeme& lexeme);
 
+    /// Read raw data.
+    /// @deprecated
+    ///     This method is only intended as a temporary measure to implement
+    ///     binary-level macro caching, to provide a reference for performance
+    ///     testing of the envisioned token-level macro caching.
+    bool GetRaw(unsigned char* buffer, size_t size);
+
     /// Get current source for comparison.
     ConstSourcePtr GetSource() const;