Merge branch 'dev' into jr/abi

Author: jeremy-rifkin

CMakeLists.txt

@@ -150,6 +150,7 @@ target_sources(
     src/utils/io/memory_file_view.cpp
     src/utils/error.cpp
     src/utils/microfmt.cpp
+    src/utils/replace_all.cpp
     src/utils/string_view.cpp
     src/utils/utils.cpp
     src/platform/dbghelp_utils.cpp

README.md

@@ -25,6 +25,7 @@ Cpptrace also has a C API, docs [here](docs/c-api.md).
   - [Utilities](#utilities)
   - [Formatting](#formatting)
     - [Transforms](#transforms)
+    - [Formatting Utilities](#formatting-utilities)
   - [Configuration](#configuration)
     - [Logging](#logging)
   - [Traces From All Exceptions](#traces-from-all-exceptions)
@@ -350,6 +351,7 @@ namespace cpptrace {
         formatter& snippets(bool);
         formatter& snippet_context(int);
         formatter& columns(bool);
+        formatter& prettify_symbols(bool);
         formatter& filtered_frame_placeholders(bool);
         formatter& filter(std::function<bool(const stacktrace_frame&)>);
         formatter& transform(std::function<stacktrace_frame(stacktrace_frame)>);
@@ -387,6 +389,7 @@ Options:
 | `snippets`                    | Whether to include source code snippets                        | `false`                                                                  |
 | `snippet_context`             | How many lines of source context to show in a snippet          | `2`                                                                      |
 | `columns`                     | Whether to include column numbers if present                   | `true`                                                                   |
+| `prettify_symbols`            | Whether to attempt to clean up long symbol names               | `false`                                                                  |
 | `filtered_frame_placeholders` | Whether to still print filtered frames as just `#n (filtered)` | `true`                                                                   |
 | `filter`                      | A predicate to filter frames with                              | None                                                                     |
 | `transform`                   | A transformer which takes a stacktrace frame and modifies it   | None                                                                     |
@@ -396,6 +399,10 @@ colors for the `formatter::format` method and it may not be able to detect if so
 not. For this reason, `formatter::format` and `formatter::print` methods have overloads taking a color parameter. This
 color parameter will override configured color mode.
 
+The `prettify_symbols` option applies a number of simple rewrite rules to symbols in an attempt to clean them up, e.g.
+it rewrites `foo(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >)`
+as `foo(std::vector<std::string>)`.
+
 Recommended practice with formatters: It's generally preferable to create formatters objects that are long-lived rather
 than to create them on the fly every time a trace needs to be formatted.
 
@@ -419,6 +426,18 @@ auto formatter = cpptrace::formatter{}
     });
 ```
 
+### Formatting Utilities
+
+Cpptrace exports a couple formatting utilities used internally which might be useful for custom formatters that don't
+use `cpptrace::formatter`:
+
+```cpp
+namespace cpptrace {
+    std::string basename(const std::string& path);
+    std::string prettify_symbol(std::string symbol);
+}
+```
+
 ## Configuration
 
 `cpptrace::absorb_trace_exceptions`: Configure whether the library silently absorbs internal exceptions and continues.

include/cpptrace/basic.hpp

@@ -166,7 +166,7 @@ CPPTRACE_BEGIN_NAMESPACE
 
         std::string to_string() const;
         std::string to_string(bool color) const;
-        friend std::ostream& operator<<(std::ostream& stream, const stacktrace_frame& frame);
+        friend CPPTRACE_EXPORT std::ostream& operator<<(std::ostream& stream, const stacktrace_frame& frame);
     };
 
     struct CPPTRACE_EXPORT stacktrace {
@@ -182,7 +182,7 @@ CPPTRACE_BEGIN_NAMESPACE
         void clear();
         bool empty() const noexcept;
         std::string to_string(bool color = false) const;
-        friend std::ostream& operator<<(std::ostream& stream, const stacktrace& trace);
+        friend CPPTRACE_EXPORT std::ostream& operator<<(std::ostream& stream, const stacktrace& trace);
 
         using iterator = std::vector<stacktrace_frame>::iterator;
         using const_iterator = std::vector<stacktrace_frame>::const_iterator;

include/cpptrace/formatting.hpp

@@ -7,6 +7,9 @@
 #include <functional>
 
 CPPTRACE_BEGIN_NAMESPACE
+    CPPTRACE_EXPORT std::string basename(const std::string& path);
+    CPPTRACE_EXPORT std::string prettify_symbol(std::string symbol);
+
     class CPPTRACE_EXPORT formatter {
         class impl;
         // can't be a std::unique_ptr due to msvc awfulness with dllimport/dllexport and https://stackoverflow.com/q/4145605/15675011
@@ -44,6 +47,7 @@ CPPTRACE_BEGIN_NAMESPACE
         formatter& snippets(bool);
         formatter& snippet_context(int);
         formatter& columns(bool);
+        formatter& prettify_symbols(bool);
         formatter& filtered_frame_placeholders(bool);
         formatter& filter(std::function<bool(const stacktrace_frame&)>);
         formatter& transform(std::function<stacktrace_frame(stacktrace_frame)>);

src/formatting.cpp

@@ -3,16 +3,60 @@
 
 #include "utils/optional.hpp"
 #include "utils/utils.hpp"
+#include "utils/replace_all.hpp"
 #include "snippets/snippet.hpp"
 
-#include <memory>
 #include <cstdio>
 #include <string>
 #include <functional>
 #include <iostream>
 #include <sstream>
+#include <regex>
 
 CPPTRACE_BEGIN_NAMESPACE
+    std::string basename(const std::string& path) {
+        return internal::basename(path, true);
+    }
+
+    std::string prettify_symbol(std::string symbol) {
+        // > > -> >> replacement
+        // could put in analysis:: but the replacement is basic and this is more convenient for
+        // using in the stringifier too
+        internal::replace_all_dynamic(symbol, "> >", ">>");
+        // "," -> ", " and " ," -> ", "
+        static const std::regex comma_re(R"(\s*,\s*)");
+        internal::replace_all(symbol, comma_re, ", ");
+        // class C -> C for msvc
+        static const std::regex class_re(R"(\b(class|struct)\s+)");
+        internal::replace_all(symbol, class_re, "");
+        // `anonymous namespace' -> (anonymous namespace) for msvc
+        // this brings it in-line with other compilers and prevents any tokenization/highlighting issues
+        static const std::regex msvc_anonymous_namespace("`anonymous namespace'");
+        internal::replace_all(symbol, msvc_anonymous_namespace, "(anonymous namespace)");
+        // rules to replace std::basic_string -> std::string and std::basic_string_view -> std::string
+        // rule to replace ", std::allocator<whatever>"
+        static const std::pair<std::regex, std::string> basic_string = {
+            std::regex(R"(std(::[a-zA-Z0-9_]+)?::basic_string<char)"), "std::string"
+        };
+        internal::replace_all_template(symbol, basic_string);
+        static const std::pair<std::regex, std::string> basic_string_view = {
+            std::regex(R"(std(::[a-zA-Z0-9_]+)?::basic_string_view<char)"), "std::string_view"
+        };
+        internal::replace_all_template(symbol, basic_string_view);
+        static const std::pair<std::regex, std::string> allocator = {
+            std::regex(R"(,\s*std(::[a-zA-Z0-9_]+)?::allocator<)"), ""
+        };
+        internal::replace_all_template(symbol, allocator);
+        static const std::pair<std::regex, std::string> default_delete = {
+            std::regex(R"(,\s*std(::[a-zA-Z0-9_]+)?::default_delete<)"), ""
+        };
+        internal::replace_all_template(symbol, default_delete);
+        // replace std::__cxx11 -> std:: for gcc dual abi
+        // https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html
+        internal::replace_all_dynamic(symbol, "std::__cxx11::", "std::");
+        return symbol;
+    }
+
     class formatter::impl {
         struct {
             std::string header = "Stack trace (most recent call first):";
@@ -22,6 +66,7 @@ CPPTRACE_BEGIN_NAMESPACE
             bool snippets = false;
             int context_lines = 2;
             bool columns = true;
+            bool prettify_symbols = false;
             bool show_filtered_frames = true;
             std::function<bool(const stacktrace_frame&)> filter;
             std::function<stacktrace_frame(stacktrace_frame)> transform;
@@ -49,6 +94,9 @@ CPPTRACE_BEGIN_NAMESPACE
         void columns(bool columns) {
             options.columns = columns;
         }
+        void prettify_symbols(bool prettify) {
+            options.prettify_symbols = prettify;
+        }
         void filtered_frame_placeholders(bool show) {
             options.show_filtered_frames = show;
         }
@@ -231,7 +279,10 @@ CPPTRACE_BEGIN_NAMESPACE
                 microfmt::print(stream, "{}0x{>{}:0h}{} ", blue, 2 * sizeof(frame_ptr), address, reset);
             }
             if(!frame.symbol.empty()) {
-                microfmt::print(stream, "in {}{}{}", yellow, frame.symbol, reset);
+                microfmt::print(
+                    stream, "in {}{}{}",
+                    yellow, options.prettify_symbols ? prettify_symbol(frame.symbol) : frame.symbol, reset
+                );
             }
             if(!frame.filename.empty()) {
                 microfmt::print(
@@ -302,6 +353,10 @@ CPPTRACE_BEGIN_NAMESPACE
         pimpl->columns(columns);
         return *this;
     }
+    formatter& formatter::prettify_symbols(bool prettify) {
+        pimpl->prettify_symbols(prettify);
+        return *this;
+    }
     formatter& formatter::filtered_frame_placeholders(bool show) {
         pimpl->filtered_frame_placeholders(show);
         return *this;

src/utils/replace_all.cpp

@@ -0,0 +1,54 @@
+#include "utils/replace_all.hpp"
+
+namespace cpptrace {
+namespace internal {
+    void replace_all(std::string& str, string_view substr, string_view replacement) {
+        std::string::size_type pos = 0;
+        while((pos = str.find(substr.data(), pos, substr.size())) != std::string::npos) {
+            str.replace(pos, substr.size(), replacement.data(), replacement.size());
+            pos += replacement.size();
+        }
+    }
+
+    void replace_all(std::string& str, const std::regex& re, string_view replacement) {
+        std::smatch match;
+        std::size_t i = 0;
+        while(std::regex_search(str.cbegin() + i, str.cend(), match, re)) {
+            str.replace(i + match.position(), match.length(), replacement.data(), replacement.size());
+            i += match.position() + replacement.size();
+        }
+    }
+
+    void replace_all_dynamic(std::string& str, string_view substr, string_view replacement) {
+        std::string::size_type pos = 0;
+        while((pos = str.find(substr.data(), pos, substr.size())) != std::string::npos) {
+            str.replace(pos, substr.size(), replacement.data(), replacement.size());
+            // advancing by one rather than replacement.length() in case replacement leads to
+            // another replacement opportunity, e.g. folding > > > to >> > then >>>
+            pos++;
+        }
+    }
+
+    void replace_all_template(std::string& str, const std::pair<std::regex, string_view>& rule) {
+        const auto& re = rule.first;
+        const auto& replacement = rule.second;
+        std::smatch match;
+        std::size_t cursor = 0;
+        while(std::regex_search(str.cbegin() + cursor, str.cend(), match, re)) {
+            // find matching >
+            const std::size_t match_begin = cursor + match.position();
+            std::size_t end = match_begin + match.length();
+            for(int c = 1; end < str.size() && c > 0; end++) {
+                if(str[end] == '<') {
+                    c++;
+                } else if(str[end] == '>') {
+                    c--;
+                }
+            }
+            // make the replacement
+            str.replace(match_begin, end - match_begin, replacement.data(), replacement.size());
+            cursor = match_begin + replacement.size();
+        }
+    }
+}
+}

src/utils/replace_all.hpp

@@ -0,0 +1,25 @@
+#ifndef REPLACE_ALL
+#define REPLACE_ALL
+
+#include <string>
+#include <regex>
+
+#include "utils/string_view.hpp"
+
+namespace cpptrace {
+namespace internal {
+    // replace all instances of substr with the replacement
+    void replace_all(std::string& str, string_view substr, string_view replacement);
+
+    // replace all regex matches with the replacement
+    void replace_all(std::string& str, const std::regex& re, string_view replacement);
+
+    // replace all instances of substr with the replacement, including new instances introduced by the replacement
+    void replace_all_dynamic(std::string& str, string_view substr, string_view replacement);
+
+    // replace all matches of a regex including template parameters
+    void replace_all_template(std::string& str, const std::pair<std::regex, string_view>& rule);
+}
+}
+
+#endif

test/link_test.cpp

@@ -1,6 +1,7 @@
-#include "cpptrace/basic.hpp"
-#include "cpptrace/utils.hpp"
-#include <cpptrace/cpptrace.hpp>
+#include <cpptrace/basic.hpp>
+#include <cpptrace/utils.hpp>
+#include <cpptrace/formatting.hpp>
+#include <cpptrace/exceptions.hpp>
 
 #include <iostream>
 
@@ -79,4 +80,7 @@ int main() {
 
     cpptrace::experimental::set_dwarf_resolver_line_table_cache_size(100);
     cpptrace::experimental::set_dwarf_resolver_disable_aranges(true);
+
+    cpptrace::basename("");
+    cpptrace::prettify_symbol("");
 }

test/unit/lib/formatting.cpp

@@ -369,4 +369,29 @@ TEST(FormatterTest, CopySemantics) {
     );
 }
 
+TEST(FormatterTest, PrettySymbols) {
+    auto normal_formatter = cpptrace::formatter{}
+        .prettify_symbols(false);
+    cpptrace::stacktrace trace;
+    trace.frames.push_back({0x1, 0x1001, {20}, {30}, "foo.cpp", "foo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)", false});
+    auto res = split(normal_formatter.format(trace), "\n");
+    EXPECT_THAT(
+        res,
+        ElementsAre(
+            "Stack trace (most recent call first):",
+            "#0 0x0000000000000001 in foo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >) at foo.cpp:20:30"
+        )
+    );
+    auto pretty_formatter = cpptrace::formatter{}
+        .prettify_symbols(true);
+    res = split(pretty_formatter.format(trace), "\n");
+    EXPECT_THAT(
+        res,
+        ElementsAre(
+            "Stack trace (most recent call first):",
+            "#0 0x0000000000000001 in foo(std::string) at foo.cpp:20:30"
+        )
+    );
+}
+
 }