PP #include non-functional: consistent notation for "header" and "header name".

glslang/Include/revision.h

@@ -2,5 +2,5 @@
 // For the version, it uses the latest git tag followed by the number of commits.
 // For the date, it uses the current date (when then script is run).
 
-#define GLSLANG_REVISION "Overload400-PrecQual.1747"
+#define GLSLANG_REVISION "Overload400-PrecQual.1748"
 #define GLSLANG_DATE "06-Jan-2017"

glslang/MachineIndependent/preprocessor/Pp.cpp

@@ -607,14 +607,14 @@ int TPpContext::CPPinclude(TPpToken* ppToken)
     // Process well-formed directive
     TShader::Includer::IncludeResult* res = includer.include(filename.c_str(), includeType, currentSourceFile.c_str(),
                                                              includeStack.size() + 1);
-    if (res && !res->file_name.empty()) {
-        if (res->file_data && res->file_length) {
+    if (res && !res->headerName.empty()) {
+        if (res->headerData && res->headerLength) {
             // path for processing one or more tokens from an included header, hand off 'res'
             const bool forNextLine = parseContext.lineDirectiveShouldSetNextLine();
             std::ostringstream prologue;
             std::ostringstream epilogue;
-            prologue << "#line " << forNextLine << " " << "\"" << res->file_name << "\"\n";
-            epilogue << (res->file_data[res->file_length - 1] == '\n'? "" : "\n") <<
+            prologue << "#line " << forNextLine << " " << "\"" << res->headerName << "\"\n";
+            epilogue << (res->headerData[res->headerLength - 1] == '\n'? "" : "\n") <<
                 "#line " << directiveLoc.line + forNextLine << " " << directiveLoc.getStringNameOrNum() << "\n";
             pushInput(new TokenizableIncludeFile(directiveLoc, prologue.str(), res, epilogue.str(), this));
             // There's no "current" location anymore.
@@ -626,7 +626,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken)
     } else {
         // error path, clean up
         std::string message =
-            res ? std::string(res->file_data, res->file_length)
+            res ? std::string(res->headerData, res->headerLength)
                 : std::string("Could not process include directive");
         parseContext.ppError(directiveLoc, message.c_str(), "#include", "for header name: %s", filename.c_str());
         includer.releaseInclude(res);

glslang/MachineIndependent/preprocessor/PpContext.h

@@ -507,11 +507,11 @@ protected:
               stringInput(pp, scanner)
         {
               strings[0] = prologue_.data();
-              strings[1] = includedFile_->file_data;
+              strings[1] = includedFile_->headerData;
               strings[2] = epilogue_.data();
 
               lengths[0] = prologue_.size();
-              lengths[1] = includedFile_->file_length;
+              lengths[1] = includedFile_->headerLength;
               lengths[2] = epilogue_.size();
 
               scanner.setLine(startLoc.line);
@@ -552,7 +552,7 @@ protected:
         // Points to the IncludeResult that this TokenizableIncludeFile represents.
         TShader::Includer::IncludeResult* includedFile_;
 
-        // Will point to prologue_, includedFile_->file_data and epilogue_
+        // Will point to prologue_, includedFile_->headerData and epilogue_
         // This is passed to scanner constructor.
         // These do not own the storage and it must remain valid until this
         // object has been destroyed.
@@ -576,7 +576,7 @@ protected:
 
     void push_include(TShader::Includer::IncludeResult* result)
     {
-        currentSourceFile = result->file_name;
+        currentSourceFile = result->headerName;
         includeStack.push(result);
     }
 
@@ -588,7 +588,7 @@ protected:
         if (includeStack.empty()) {
             currentSourceFile = rootFileName;
         } else {
-            currentSourceFile = includeStack.top()->file_name;
+            currentSourceFile = includeStack.top()->headerName;
         }
     }
 

glslang/Public/ShaderLang.h

@@ -339,22 +339,22 @@ public:
         // An IncludeResult contains the resolved name and content of a source
         // inclusion.
         struct IncludeResult {
-            IncludeResult(const std::string& file_name, const char* const file_data, const size_t file_length, void* user_data) :
-                file_name(file_name), file_data(file_data), file_length(file_length), user_data(user_data) { }
+            IncludeResult(const std::string& headerName, const char* const headerData, const size_t headerLength, void* userData) :
+                headerName(headerName), headerData(headerData), headerLength(headerLength), userData(userData) { }
             // For a successful inclusion, the fully resolved name of the requested
             // include.  For example, in a file system-based includer, full resolution
             // should convert a relative path name into an absolute path name.
             // For a failed inclusion, this is an empty string.
-            const std::string file_name;
+            const std::string headerName;
             // The content and byte length of the requested inclusion.  The
             // Includer producing this IncludeResult retains ownership of the
             // storage.
-            // For a failed inclusion, the file_data
+            // For a failed inclusion, the header
             // field points to a string containing error details.
-            const char* const file_data;
-            const size_t file_length;
+            const char* const headerData;
+            const size_t headerLength;
             // Include resolver's context.
-            void* user_data;
+            void* userData;
         protected:
             IncludeResult& operator=(const IncludeResult&);
             IncludeResult();
@@ -364,15 +364,15 @@ public:
         // and include depth.
         // On success, returns an IncludeResult containing the resolved name
         // and content of the include.  On failure, returns an IncludeResult
-        // with an empty string for the file_name and error details in the
-        // file_data field.  The Includer retains ownership of the contents
+        // with an empty string for the headerName and error details in the
+        // header field.  The Includer retains ownership of the contents
         // of the returned IncludeResult value, and those contents must
         // remain valid until the releaseInclude method is called on that
         // IncludeResult object.
-        virtual IncludeResult* include(const char* requested_source,
+        virtual IncludeResult* include(const char* headerName,
                                       IncludeType type,
-                                      const char* requesting_source,
-                                      size_t inclusion_depth) = 0;
+                                      const char* includerName,
+                                      size_t inclusionDepth) = 0;
         // Signals that the parser will no longer use the contents of the
         // specified IncludeResult.
         virtual void releaseInclude(IncludeResult* result) = 0;