Ticket #3640: preprocessor_include_with_hotload_impl_fixed.patch

source/graphics/ShaderProgram.h

@@ -193 +193 @@
      */
     void AssertPointersBound();
 
+    /**
+    * Register observer to be notified on each included file
+    */
+    void RegisterIncludedFilesObserver(std::function<void(const VfsPath&)>);
+
 protected:
     CShaderProgram(int streamflags);
 
@@ -203 +208 @@
     void BindClientStates();
     void UnbindClientStates();
     int m_ValidStreams; // which streams have been specified via VertexPointer etc since the last Bind
+
+    std::function<void(const VfsPath&)> IncludedFileObserver;
 };
 
 #endif // INCLUDED_SHADERPROGRAM

source/graphics/ShaderProgram.cpp

@@ -432 +432 @@
 
         CPreprocessorWrapper preprocessor;
         preprocessor.AddDefines(m_Defines);
+        preprocessor.RegisterIncludedFilesObserver(IncludedFileObserver);
 
 #if CONFIG2_GLES
         // GLES defines the macro "GL_ES" in its GLSL preprocessor,
@@ -890 +891 @@
 {
     ENSURE((m_StreamFlags & ~m_ValidStreams) == 0);
 }
+
+void CShaderProgram::RegisterIncludedFilesObserver(std::function<void(const VfsPath&)> fileObserver)
+{
+    IncludedFileObserver = fileObserver;
+}

source/graphics/ShaderManager.h

@@ -72 +72 @@
      */
     size_t GetNumEffectsLoaded();
 
+    /**
+    * Associates file with program to be reloaded if file has changed
+    */
+    void AddHotloadFile(const VfsPath&, CShaderProgramPtr program);
+
 private:
 
     struct CacheKey

source/graphics/ShaderManager.cpp

@@ -265 +265 @@
     else
         program = CShaderProgramPtr(CShaderProgram::ConstructARB(vertexFile, fragmentFile, defines, vertexUniforms, fragmentUniforms, streamFlags));
 
+    // add included file listener
+    program->RegisterIncludedFilesObserver(std::bind(&CShaderManager::AddHotloadFile, this, std::placeholders::_1, program));
+
     program->Reload();
 
 //  m_HotloadFiles[xmlFilename].insert(program); // TODO: should reload somehow when the XML changes
@@ -556 +559 @@
     return m_EffectCache.size();
 }
 
+void CShaderManager::AddHotloadFile(const VfsPath& filename, CShaderProgramPtr program)
+{
+    m_HotloadFiles[filename].insert(program);
+}
+
 /*static*/ Status CShaderManager::ReloadChangedFileCB(void* param, const VfsPath& path)
 {
     return static_cast<CShaderManager*>(param)->ReloadChangedFile(path);
@@ -568 +576 @@
     if (files != m_HotloadFiles.end())
     {
         // Reload all shaders using this file
-        for (std::set<std::weak_ptr<CShaderProgram> >::iterator it = files->second.begin(); it != files->second.end(); ++it)
+        for (std::weak_ptr<CShaderProgram> p : files->second)
         {
-            if (std::shared_ptr<CShaderProgram> program = it->lock())
+            std::shared_ptr<CShaderProgram> program = p.lock();
+            if (program != NULL)
                 program->Reload();
         }
     }

source/ps/PreprocessorWrapper.h

@@ -37 +37 @@
 
     CStr Preprocess(const CStr& input);
 
+    void RegisterIncludedFilesObserver(std::function<void(const VfsPath&)>);
+
 private:
     CPreprocessor m_Preprocessor;
 };

source/ps/PreprocessorWrapper.cpp

@@ -84 +84 @@
 
     return ret;
 }
+
+void CPreprocessorWrapper::RegisterIncludedFilesObserver(std::function<void(const VfsPath&)> observer)
+{
+    m_Preprocessor.RegisterIncludedFilesObserver(observer);
+}

source/ps/Preprocessor.h

@@ -35 +35 @@
 #ifndef INCLUDED_CPREPROCESSOR
 #define INCLUDED_CPREPROCESSOR
 
+#include <functional>
+
+// Forward declare VfsPath, which is typedefed Path
+class Path;
+typedef Path VfsPath;
+
 /**
  * This is a simplistic C/C++-like preprocessor.
  * It takes an non-zero-terminated string on input and outputs a
@@ -200 +206 @@
 
         /// Expand the macro value (will not work for functions)
         Token Expand (int iNumArgs, Token *iArgs, Macro *iMacros);
+
+        /// Performs deep copy of this macro
+        Macro *Copy() const;
     };
 
     friend class CPreprocessor::Macro;
@@ -217 +226 @@
     /// The list of macros defined so far
     Macro *MacroList;
 
+    /// Listener to be notified about new included files
+    std::function<void(const VfsPath&)> IncludedFileObserver;
+
     /**
      * Private constructor to re-parse a single token.
      */
@@ -278 +290 @@
      */
     bool HandleIfDef (Token &iBody, int iLine);
 
+    /**
+    * Handle a \#include directive.
+    * @param iBody
+    *     The body of the directive (everything after the directive
+    *     until end of line).
+    * @param iLine
+    *     The line where the directive begins (for error reports)
+    * @return
+    *     Included text enclosed in a token
+    */
+    Token HandleInclude (Token &iBody, int iLine);
+
     /**
      * Handle an \#if directive.
      * @param iBody
@@ -508 +532 @@
      */
     char *Parse (const char *iSource, size_t iLength, size_t &oLength);
 
+    /**
+    * Register observer to be notified on each included file
+    */
+    void RegisterIncludedFilesObserver (std::function<void(const VfsPath&)>);
+
     /**
      * An error handler function type.
      * The default implementation just drops a note to stderr and

source/ps/Preprocessor.cpp

@@ -38 +38 @@
 
 #include "ps/CLogger.h"
 
+#include "ps/Filesystem.h" // to handle #include
+
 // Limit max number of macro arguments to this
 #define MAX_MACRO_ARGS 16
 
@@ -224 +226 @@
     return xt;
 }
 
+CPreprocessor::Macro *CPreprocessor::Macro::Copy () const
+{
+    Token mainCopy;
+
+    // Copy buffer once
+    size_t maxLength = this->Body.Length;
+    if (this->Name.Length > maxLength)
+        maxLength = this->Name.Length;
+    if (this->Value.Length > maxLength)
+        maxLength = this->Value.Length;
+
+    char *buffer = new char[maxLength];
+    strncpy(buffer, this->Body.String, maxLength);
+
+    // Copy each subcomponent of Macro
+    Token body = Token(this->Body.Type, buffer, this->Body.Length);
+    Token name = Token(this->Name.Type, buffer, this->Name.Length);
+    Token value = Token(this->Value.Type, buffer + (this->Value.Buffer - this->Body.Buffer), this->Value.Length);
+
+    // TODO: Ignore Args for now
+
+    Macro *macroCopy = new Macro(name);
+    macroCopy->Body = body;
+    macroCopy->Value = value;
+
+    return macroCopy;
+}
+
 //---------------------------------------------------------------------------//
 
 static void DefaultError (void *iData, int iLine, const char *iError,
@@ -979 +1009 @@
     return true;
 }
 
+CPreprocessor::Token CPreprocessor::HandleInclude (Token &iBody, int iLine)
+{
+    CPreprocessor cpp(iBody, iLine);
+
+    Token t = cpp.GetToken(false);
+
+    if (t.Type != Token::TK_STRING)
+    {
+        Error(iLine, "Expecting a file name after #include, got", &t);
+        return Token();
+    }
+
+    std::string filename = std::string(t.String).substr(0, t.Length);
+    ENSURE(filename.at(0) == '"' && filename.at(t.Length-1) == '"');
+    filename = filename.substr(1, t.Length - 2); // remove '"' symbols from the beginning and from the end of token
+
+    CVFSFile includedFile;
+    const VfsPath includedFilePath(L"shaders/" + wstring_from_utf8(filename));
+    if (includedFile.Load(g_VFS, includedFilePath) != PSRETURN_OK)
+        Error(iLine, "Warning: File not found", &t);
+    IncludedFileObserver(includedFilePath);
+    const CStr& input = includedFile.GetAsString();
+
+    size_t len = 0;
+    CPreprocessor preprocessor;
+    ENSURE(input.size() > 0);
+    std::string includedSources = preprocessor.Parse(input.c_str(), input.size(), len);
+    char *result = new char[len];
+    includedSources.copy(result, len);
+
+    // Copy macros
+    Macro *m = preprocessor.MacroList;
+    while (m)
+    {
+        Macro *copy = m->Copy();
+        copy->Next = MacroList;
+        MacroList = copy;
+        m = m->Next;
+    }
+
+    if (!result)
+    {
+        Error(iLine, "Problem during preprocessing of included file", &t);
+        return Token();
+    }
+
+    do
+    {
+        t = cpp.GetToken(false);
+    } while (t.Type == Token::TK_WHITESPACE ||
+        t.Type == Token::TK_COMMENT ||
+        t.Type == Token::TK_LINECOMMENT);
+
+    if (t.Type != Token::TK_EOS)
+        Error(iLine, "Warning: Ignoring garbage after directive", &t);
+
+    return Token(Token::TK_STRING, result, len);;
+}
+
 CPreprocessor::Token CPreprocessor::ExpandDefined (CPreprocessor *iParent, int iNumArgs, Token *iArgs)
 {
     if (iNumArgs != 1)
@@ -1125 +1214 @@
         if (rc)
             EnableOutput ^= 1;
     }
+    else if (IS_DIRECTIVE ("include"))
+        return HandleInclude (t, iLine);
     else if (IS_DIRECTIVE ("if"))
         rc = HandleIf (t, iLine);
     else if (IS_DIRECTIVE ("else"))
@@ -1311 +1402 @@
     retval.Allocated = 0;
     return retval.Buffer;
 }
+
+void CPreprocessor::RegisterIncludedFilesObserver(std::function<void(const VfsPath&)> fileObserver)
+{
+    IncludedFileObserver = fileObserver;
+}