Ticket #5588: path_resolver.patch

new file property_tree/detail/info_parser_default_path_resolver.hpp

@@ +1 @@
+#ifndef BOOST_PROPERTY_TREE_DETAIL_INFO_PARSER_DEFAULT_PATH_RESOLVER_HPP_INCLUDED
+#define BOOST_PROPERTY_TREE_DETAIL_INFO_PARSER_DEFAULT_PATH_RESOLVER_HPP_INCLUDED
+
+namespace boost { namespace property_tree { namespace info_parser
+{
+    /*!
+     * \brief Path resolver class implementation
+     *
+     * This implementation will not resolve
+     * paths: it will simply return
+     * path argument. It was created
+     * for compatibility purposes.
+     */
+    class default_path_resolver
+    {
+    public:
+        inline const std::string &resolve(const std::string &path)
+        {
+            return path;
+        }
+        inline void enter(const std::string &) {}
+        inline void enter() {}
+        inline void exit() {}
+    };
+} } }
+
+#endif

property_tree/detail/info_parser_read.hpp

@@ -175 +175 @@
     }
 
     // Build ptree from info stream
-    template<class Ptree, class Ch>
+    template<class Ptree, class Ch, class PathResolver>
     void read_info_internal(std::basic_istream<Ch> &stream,
                             Ptree &pt,
                             const std::string &filename,
+                            PathResolver &path_resolver,
                             int include_depth)
     {
         typedef std::basic_string<Ch> str_t;
@@ -227 +228 @@
                         str_t s = read_string(text, NULL);
                         std::string inc_name =
                             convert_chtype<char, Ch>(s.c_str());
-                        std::basic_ifstream<Ch> inc_stream(inc_name.c_str());
+                        std::basic_ifstream<Ch> inc_stream(
+                            path_resolver.resolve(inc_name.c_str()));
                         if (!inc_stream.good())
                             BOOST_PROPERTY_TREE_THROW(info_parser_error(
                                 "cannot open include file " + inc_name,
                                 filename, line_no));
+                        path_resolver.enter(inc_name);
                         read_info_internal(inc_stream, *stack.top(),
-                                           inc_name, include_depth + 1);
+                                           inc_name, path_resolver,
+                                           include_depth + 1);
+                        path_resolver.exit();
                     } else {   // Unknown directive
                         BOOST_PROPERTY_TREE_THROW(info_parser_error(
                             "unknown directive", filename, line_no));

new file property_tree/detail/info_parser_relative_path_resolver.hpp

@@ +1 @@
+#ifndef BOOST_PROPERTY_TREE_DETAIL_INFO_PARSER_RELATIVE_PATH_RESOLVER_HPP_INCLUDED
+#define BOOST_PROPERTY_TREE_DETAIL_INFO_PARSER_RELATIVE_PATH_RESOLVER_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+#include <stack>
+
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+
+namespace boost { namespace property_tree { namespace info_parser
+{
+    /*!
+     * \brief Path resolver class implementation
+     * that resolves paths relatively
+     *
+     * This implementation will resolve paths
+     * relative to base path (directory path of the file contains '#include' directive)
+     *
+     * \note The drawback of this implementation
+     * is dependency on boost::filesystem library
+     *
+     */
+    class relative_path_resolver
+    {
+        std::stack<boost::filesystem::path> stack;
+        inline boost::filesystem::path resolve_(const boost::filesystem::path &path)
+        {
+            if (path.is_absolute())
+                return path;
+            else
+            {
+                if (stack.empty())
+                    return boost::filesystem::absolute(boost::filesystem::current_path()/path);
+                else
+                    return boost::filesystem::absolute(stack.top()/path);
+            }
+        }
+    public:
+        inline std::string resolve(const boost::filesystem::path &path)
+        {
+            return resolve(path).string();
+        }
+        inline void enter(const boost::filesystem::path &path)
+        {
+            stack.push(resolve_(path).parent_path());
+        }
+        inline void enter()
+        {
+            if (stack.empty())
+                stack.push(boost::filesystem::current_path());
+            else
+                // this case is unreachable
+                // probably should not be used
+                // TODO: should we use BOOST_ASSERT here?
+                stack.push(stack.top());
+        }
+        inline void exit()
+        {
+            stack.pop();
+        }
+    };
+} } }
+
+#endif

property_tree/info_parser.hpp

@@ -15 +15 @@
 #include <boost/property_tree/detail/info_parser_writer_settings.hpp>
 #include <boost/property_tree/detail/info_parser_read.hpp>
 #include <boost/property_tree/detail/info_parser_write.hpp>
+#include <boost/property_tree/detail/info_parser_default_path_resolver.hpp>
 #include <istream>
 
 namespace boost { namespace property_tree { namespace info_parser
@@ -29 +30 @@
     template<class Ptree, class Ch>
     void read_info(std::basic_istream<Ch> &stream, Ptree &pt)
     {
+        default_path_resolver path_resolver;
+        read_info(stream, pt, path_resolver);
+    }
+
+    template<class Ptree, class Ch, class PathResolver>
+    void read_info(std::basic_istream<Ch> &stream, Ptree &pt,
+                   PathResolver &path_resolver)
+    {
         Ptree local;
-        read_info_internal(stream, local, std::string(), 0);
+        path_resolver.enter();
+        read_info_internal(stream, local, std::string(), path_resolver, 0);
+        path_resolver.exit();
         pt.swap(local);
     }
 
@@ -43 +54 @@
     void read_info(std::basic_istream<Ch> &stream, Ptree &pt,
                    const Ptree &default_ptree)
     {
+        default_path_resolver path_resolver;
+        read_info(stream, pt, default_ptree, path_resolver);
+    }
+
+    template<class Ptree, class Ch, class PathResolver>
+    void read_info(std::basic_istream<Ch> &stream, Ptree &pt,
+                   const Ptree &default_ptree, PathResolver &path_resolver)
+    {
         try {
-            read_info(stream, pt);
+            path_resolver.enter();
+            read_info(stream, pt, path_resolver);
+            path_resolver.exit();
         } catch(file_parser_error &) {
             pt = default_ptree;
         }
@@ -62 +83 @@
     void read_info(const std::string &filename, Ptree &pt,
                    const std::locale &loc = std::locale())
     {
+        default_path_resolver path_resolver;
+        read_info(filename, pt, path_resolver, loc);
+    }
+
+    template<class Ptree, class PathResolver>
+    void read_info(const std::string &filename, Ptree &pt,
+                   PathResolver &path_resolver,
+                   const std::locale &loc = std::locale())
+    {
         std::basic_ifstream<typename Ptree::key_type::value_type>
             stream(filename.c_str());
         if (!stream) {
@@ -70 +100 @@
         }
         stream.imbue(loc);
         Ptree local;
-        read_info_internal(stream, local, filename, 0);
+        path_resolver.enter(filename);
+        read_info_internal(stream, local, filename, path_resolver, 0);
+        path_resolver.exit();
         pt.swap(local);
     }
 
@@ -81 +113 @@
      * @note Replaces the existing contents. Strong exception guarantee.
      * @param default_ptree If parsing fails, pt is set to a copy of this tree.
      */
-    template<class Ptree>
+    template<class Ptree, class PathResolver>
+    void read_info(const std::string &filename,
+                   Ptree &pt,
+                   const Ptree &default_ptree,
+                   const std::locale &loc = std::locale())
+    {
+        default_path_resolver path_resolver;
+        read_info(filename, pt, default_ptree, loc, path_resolver);
+    }
+
+    template<class Ptree, class PathResolver>
     void read_info(const std::string &filename,
                    Ptree &pt,
                    const Ptree &default_ptree,
+                   PathResolver &path_resolver,
                    const std::locale &loc = std::locale())
     {
         try {
-            read_info(filename, pt, loc);
+            read_info(filename, pt, path_resolver, loc);
         } catch(file_parser_error &) {
             pt = default_ptree;
         }