[modernize] some more cleanups

docs/source/sqltab.rst

@@ -137,6 +137,8 @@ with the **lnav_view_filter_stats** table into a single view for ease of use.
 all_logs
 --------
 
+.. f0:sql.tables.all_logs
+
 The **all_logs** table lets you query the format derived from the **lnav**
 log message parser that is used to automatically extract data, see
 :ref:`data-ext` for more details.

docs/source/usage.rst

@@ -47,6 +47,8 @@ by pressing :kbd:`t`.
 Archive Support
 ^^^^^^^^^^^^^^^
 
+.. f0:archive
+
 If **lnav** is compiled with `libarchive <https://www.libarchive.org>`_,
 any files to be opened will be examined to see if they are a supported archive
 type.  If so, the contents of the archive will be extracted to the

src/CMakeLists.txt

@@ -343,7 +343,6 @@ add_library(
         archive_manager.hh
         archive_manager.cfg.hh
         attr_line.hh
-        auto_fd.hh
         auto_mem.hh
         big_array.hh
         bottom_status_source.hh

src/Makefile.am

@@ -158,7 +158,6 @@ noinst_HEADERS = \
 	archive_manager.hh \
 	archive_manager.cfg.hh \
 	attr_line.hh \
-	auto_fd.hh \
 	auto_mem.hh \
 	big_array.hh \
 	bin2c.hh \

src/all_logs_vtab.hh

@@ -37,6 +37,8 @@
 
 /**
  * A virtual table that provides access to all log messages from all formats.
+ *
+ * @feature f0:sql.tables.all_logs
  */
 class all_logs_vtab : public log_vtab_impl {
 public:

src/ansi_scrubber.cc

@@ -38,8 +38,6 @@
 #include "pcrepp/pcrepp.hh"
 #include "view_curses.hh"
 
-using namespace std;
-
 static pcrepp&
 ansi_regex()
 {
@@ -69,7 +67,7 @@ scrub_ansi_string(std::string& str, string_attrs_t& sa)
         switch (pi.get_substr_start(&caps[2])[0]) {
             case 'm':
                 for (lpc = caps[1].c_begin;
-                     lpc != string::npos && lpc < (size_t) caps[1].c_end;)
+                     lpc != std::string::npos && lpc < (size_t) caps[1].c_end;)
                 {
                     int ansi_code = 0;
 
@@ -103,7 +101,7 @@ scrub_ansi_string(std::string& str, string_attrs_t& sa)
                         }
                     }
                     lpc = str.find(';', lpc);
-                    if (lpc != string::npos) {
+                    if (lpc != std::string::npos) {
                         lpc += 1;
                     }
                 }

src/archive_manager.cc

@@ -40,8 +40,8 @@
 
 #include "archive_manager.cfg.hh"
 #include "archive_manager.hh"
-#include "auto_fd.hh"
 #include "auto_mem.hh"
+#include "base/auto_fd.hh"
 #include "base/fs_util.hh"
 #include "base/humanize.hh"
 #include "base/injector.hh"
@@ -87,9 +87,13 @@ public:
         auto lock_path = archive_path;
 
         lock_path += ".lck";
-        this->lh_fd
+        auto open_res
-            = lnav::filesystem::openp(lock_path, O_CREAT | O_RDWR, 0600);
+            = lnav::filesystem::open_file(lock_path, O_CREAT | O_RDWR, 0600);
-        log_perror(fcntl(this->lh_fd, F_SETFD, FD_CLOEXEC));
+        if (open_res.isErr()) {
+            throw std::runtime_error(open_res.unwrapErr());
+        }
+        this->lh_fd = open_res.unwrap();
+        this->lh_fd.close_on_exec();
     };
 
     auto_fd lh_fd;
@@ -103,6 +107,7 @@ public:
 static void
 enable_desired_archive_formats(archive* arc)
 {
+    /** @feature f0:archive.formats */
     archive_read_support_format_7zip(arc);
     archive_read_support_format_cpio(arc);
     archive_read_support_format_lha(arc);
@@ -126,9 +131,9 @@ is_archive(const fs::path& filename)
     log_debug("read open %s", filename.c_str());
     auto r = archive_read_open_filename(arc, filename.c_str(), 128 * 1024);
     if (r == ARCHIVE_OK) {
-        struct archive_entry* entry;
+        struct archive_entry* entry = nullptr;
 
-        auto format_name = archive_format_name(arc);
+        const auto* format_name = archive_format_name(arc);
 
         log_debug("read next header %s %s", format_name, filename.c_str());
         if (archive_read_next_header(arc, &entry) == ARCHIVE_OK) {
@@ -146,7 +151,7 @@ is_archive(const fs::path& filename)
                     return false;
                 }
 
-                auto first_filter_name = archive_filter_name(arc, 0);
+                const auto* first_filter_name = archive_filter_name(arc, 0);
                 if (filter_count == 2 && GZ_FILTER_NAME == first_filter_name) {
                     return false;
                 }
@@ -154,11 +159,11 @@ is_archive(const fs::path& filename)
             log_info(
                 "detected archive: %s -- %s", filename.c_str(), format_name);
             return true;
-        } else {
-            log_info("archive read header failed: %s -- %s",
-                     filename.c_str(),
-                     archive_error_string(arc));
         }
+
+        log_info("archive read header failed: %s -- %s",
+                 filename.c_str(),
+                 archive_error_string(arc));
     } else {
         log_info("archive open failed: %s -- %s",
                  filename.c_str(),
@@ -214,7 +219,7 @@ copy_data(const std::string& filename,
 
     for (;;) {
         if (total >= next_space_check) {
-            auto& cfg = injector::get<const config&>();
+            const auto& cfg = injector::get<const config&>();
             auto tmp_space = fs::space(entry_path);
 
             if (tmp_space.available < cfg.amc_min_free_space) {
@@ -256,10 +261,19 @@ copy_data(const std::string& filename,
 static walk_result_t
 extract(const std::string& filename, const extract_cb& cb)
 {
-    static int FLAGS = ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM
+    static const int FLAGS = ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM
         | ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS;
 
+    std::error_code ec;
     auto tmp_path = filename_to_tmp_path(filename);
+
+    fs::create_directories(tmp_path.parent_path(), ec);
+    if (ec) {
+        return Err(fmt::format("Unable to create directory: {} -- {}",
+                               tmp_path.parent_path().string(),
+                               ec.message()));
+    }
+
     auto arc_lock = archive_lock(tmp_path);
     auto lock_guard = archive_lock::guard(arc_lock);
     auto done_path = tmp_path;
@@ -279,10 +293,9 @@ extract(const std::string& filename, const extract_cb& cb)
             log_info("%s: archive has already been extracted!",
                      done_path.c_str());
             return Ok();
-        } else {
-            log_warning("%s: archive cache has been damaged, re-extracting",
-                        done_path.c_str());
         }
+        log_warning("%s: archive cache has been damaged, re-extracting",
+                    done_path.c_str());
 
         fs::remove(done_path);
     }
@@ -306,7 +319,7 @@ extract(const std::string& filename, const extract_cb& cb)
 
     log_info("extracting %s to %s", filename.c_str(), tmp_path.c_str());
     while (true) {
-        struct archive_entry* entry;
+        struct archive_entry* entry = nullptr;
         auto r = archive_read_next_header(arc, &entry);
         if (r == ARCHIVE_EOF) {
             log_info("all done");
@@ -319,7 +332,7 @@ extract(const std::string& filename, const extract_cb& cb)
                             archive_error_string(arc)));
         }
 
-        auto format_name = archive_format_name(arc);
+        const auto* format_name = archive_format_name(arc);
         auto filter_count = archive_filter_count(arc);
 
         auto_mem<archive_entry> wentry(archive_entry_free);
@@ -329,7 +342,7 @@ extract(const std::string& filename, const extract_cb& cb)
             desired_pathname = fs::path(filename).filename();
         }
         auto entry_path = tmp_path / desired_pathname;
-        auto prog = cb(
+        auto* prog = cb(
             entry_path,
             archive_entry_size_is_set(entry) ? archive_entry_size(entry) : -1);
         archive_entry_copy_pathname(wentry, entry_path.c_str());
@@ -343,8 +356,10 @@ extract(const std::string& filename, const extract_cb& cb)
                 fmt::format(FMT_STRING("unable to write entry: {} -- {}"),
                             entry_path.string(),
                             archive_error_string(ext)));
-        } else if (!archive_entry_size_is_set(entry)
+        }
-                   || archive_entry_size(entry) > 0) {
+
+        if (!archive_entry_size_is_set(entry) || archive_entry_size(entry) > 0)
+        {
             TRY(copy_data(filename, arc, entry, ext, entry_path, prog));
         }
         r = archive_write_finish_entry(ext);
@@ -358,7 +373,7 @@ extract(const std::string& filename, const extract_cb& cb)
     archive_read_close(arc);
     archive_write_close(ext);
 
-    auto_fd(open(done_path.c_str(), O_CREAT | O_WRONLY, 0600));
+    lnav::filesystem::open_file(done_path, O_CREAT | O_WRONLY, 0600);
 
     return Ok();
 }
@@ -400,7 +415,7 @@ cleanup_cache()
     (void) std::async(std::launch::async, []() {
         auto now = std::chrono::system_clock::now();
         auto cache_path = archive_cache_path();
-        auto& cfg = injector::get<const config&>();
+        const auto& cfg = injector::get<const config&>();
         std::vector<fs::path> to_remove;
 
         log_debug("cache-ttl %d", cfg.amc_cache_ttl.count());

src/archive_manager.hh

@@ -62,6 +62,14 @@ ghc::filesystem::path filename_to_tmp_path(const std::string& filename);
 
 using walk_result_t = Result<void, std::string>;
 
+/**
+ *
+ * @feature f0:archive
+ *
+ * @param filename
+ * @param cb
+ * @return
+ */
 walk_result_t walk_archive_files(
     const std::string& filename,
     const extract_cb& cb,

src/attr_line.hh

@@ -186,6 +186,12 @@ struct string_attr {
         require(type);
     };
 
+    string_attr(const struct line_range& lr,
+                std::pair<string_attr_type_base*, string_attr_value> value)
+        : sa_range(lr), sa_type2(value.first), sa_value2(value.second)
+    {
+    }
+
     string_attr() : sa_type(nullptr){};
 
     bool operator<(const struct string_attr& rhs) const
@@ -202,6 +208,8 @@ struct string_attr {
     string_attr_type_t sa_type;
     string_attr_value_t sa_value;
     std::string sa_str_value;
+    string_attr_type_base* sa_type2;
+    string_attr_value sa_value2;
 };
 
 /** A map of line ranges to attributes for that range. */

src/base/CMakeLists.txt

@@ -1,58 +1,59 @@
 add_library(
-  base STATIC
+        base STATIC
-  ../config.h.in
+        ../config.h.in
-  auto_pid.cc
+        auto_pid.cc
-  date_time_scanner.cc
+        date_time_scanner.cc
-  fs_util.cc
+        fs_util.cc
-  humanize.cc
+        humanize.cc
-  humanize.network.cc
+        humanize.network.cc
-  humanize.time.cc
+        humanize.time.cc
-  intern_string.cc
+        intern_string.cc
-  is_utf8.cc
+        is_utf8.cc
-  isc.cc
+        isc.cc
-  lnav.gzip.cc
+        lnav.gzip.cc
-  lnav_log.cc
+        lnav_log.cc
-  network.tcp.cc
+        network.tcp.cc
-  paths.cc
+        paths.cc
-  string_util.cc
+        string_util.cc
-  strnatcmp.c
+        strnatcmp.c
-  time_util.cc
+        time_util.cc
-  auto_pid.hh
+        auto_fd.hh
-  date_time_scanner.hh
+        auto_pid.hh
-  enum_util.hh
+        date_time_scanner.hh
-  fs_util.hh
+        enum_util.hh
-  func_util.hh
+        fs_util.hh
-  future_util.hh
+        func_util.hh
-  humanize.hh
+        future_util.hh
-  humanize.network.hh
+        humanize.hh
-  humanize.time.hh
+        humanize.network.hh
-  injector.hh
+        humanize.time.hh
-  injector.bind.hh
+        injector.hh
-  intern_string.hh
+        injector.bind.hh
-  is_utf8.hh
+        intern_string.hh
-  isc.hh
+        is_utf8.hh
-  lrucache.hpp
+        isc.hh
-  math_util.hh
+        lrucache.hpp
-  network.tcp.hh
+        math_util.hh
-  paths.hh
+        network.tcp.hh
-  result.h
+        paths.hh
-  strnatcmp.h
+        result.h
-  time_util.hh)
+        strnatcmp.h
+        time_util.hh)
 
 target_include_directories(base PUBLIC . .. ../fmtlib ../third-party
         ${CMAKE_CURRENT_BINARY_DIR}/..)
 target_link_libraries(base cppfmt pcre::libpcre ncurses::libcurses pthread)
 
 add_executable(
-  test_base
+        test_base
-  humanize.file_size.tests.cc
+        humanize.file_size.tests.cc
-  humanize.network.tests.cc
+        humanize.network.tests.cc
-  humanize.time.tests.cc
+        humanize.time.tests.cc
-  intern_string.tests.cc
+        intern_string.tests.cc
-  lnav.gzip.tests.cc
+        lnav.gzip.tests.cc
-  string_util.tests.cc
+        string_util.tests.cc
-  network.tcp.tests.cc
+        network.tcp.tests.cc
-  test_base.cc)
+        test_base.cc)
 target_include_directories(test_base PUBLIC ../third-party/doctest-root)
 target_link_libraries(test_base base pcrepp ZLIB::ZLIB)
 add_test(NAME test_base COMMAND test_base)

src/base/Makefile.am

@@ -19,6 +19,7 @@ AM_CXXFLAGS = $(CODE_COVERAGE_CXXFLAGS)
 noinst_LIBRARIES = libbase.a
 
 noinst_HEADERS = \
+    auto_fd.hh \
     auto_pid.hh \
     date_time_scanner.hh \
     enum_util.hh \

src/base/auto_fd.hh

@@ -85,14 +85,14 @@ public:
             return auto_fd{};
         }
 
-        auto new_fd = dup(fd);
+        auto new_fd = ::dup(fd);
 
         if (new_fd == -1) {
             throw std::bad_alloc();
         }
 
         return auto_fd(new_fd);
-    };
+    }
 
     /**
      * Construct an auto_fd to manage the given file descriptor.
@@ -102,7 +102,7 @@ public:
     explicit auto_fd(int fd = -1) : af_fd(fd)
     {
         require(fd >= -1);
-    };
+    }
 
     /**
      * Non-const copy constructor.  Management of the file descriptor will be
@@ -119,12 +119,18 @@ public:
      *
      * @param af The source of the file descriptor.
      */
-    auto_fd(const auto_fd& af) : af_fd(-1)
+    auto_fd(const auto_fd& af) = delete;
+
+    auto_fd dup() const
     {
-        if (af.af_fd != -1 && (this->af_fd = dup(af.af_fd)) == -1) {
+        int new_fd;
+
+        if (this->af_fd == -1 || (new_fd = ::dup(this->af_fd)) == -1) {
             throw std::bad_alloc();
         }
-    };
+
+        return auto_fd{new_fd};
+    }
 
     /**
      * Destructor that will close the file descriptor managed by this object.
@@ -212,7 +218,15 @@ public:
 
         if (this->af_fd != fd) {
             if (this->af_fd != -1) {
-                close(this->af_fd);
+                switch (this->af_fd) {
+                    case STDIN_FILENO:
+                    case STDOUT_FILENO:
+                    case STDERR_FILENO:
+                        break;
+                    default:
+                        close(this->af_fd);
+                        break;
+                }
             }
             this->af_fd = fd;
         }
@@ -240,7 +254,7 @@ public:
             return Err(std::string(strerror(errno)));
         }
 
-        return Ok(retval);
+        return Ok(std::move(retval));
     }
 
     explicit auto_pipe(int child_fd = -1, int child_flags = O_RDONLY)

src/base/fs_util.cc

@@ -36,7 +36,21 @@
 namespace lnav {
 namespace filesystem {
 
-Result<std::pair<ghc::filesystem::path, int>, std::string>
+Result<auto_fd, std::string>
+open_file(const ghc::filesystem::path& path, int flags, mode_t mode)
+{
+    auto fd = openp(path, flags, mode);
+
+    if (fd == -1) {
+        return Err(fmt::format(FMT_STRING("Failed to open: {} -- {}"),
+                               path.string(),
+                               strerror(errno)));
+    }
+
+    return Ok(auto_fd(fd));
+}
+
+Result<std::pair<ghc::filesystem::path, auto_fd>, std::string>
 open_temp_file(const ghc::filesystem::path& pattern)
 {
     auto pattern_str = pattern.string();
@@ -51,7 +65,7 @@ open_temp_file(const ghc::filesystem::path& pattern)
                         strerror(errno)));
     }
 
-    return Ok(std::make_pair(ghc::filesystem::path(pattern_copy), fd));
+    return Ok(std::make_pair(ghc::filesystem::path(pattern_copy), auto_fd(fd)));
 }
 
 Result<std::string, std::string>

src/base/fs_util.hh

@@ -33,6 +33,7 @@
 #include <string>
 #include <vector>
 
+#include "auto_fd.hh"
 #include "ghc/filesystem.hpp"
 #include "result.h"
 
@@ -57,7 +58,11 @@ openp(const ghc::filesystem::path& path, int flags, mode_t mode)
     return open(path.c_str(), flags, mode);
 }
 
-Result<std::pair<ghc::filesystem::path, int>, std::string> open_temp_file(
+Result<auto_fd, std::string> open_file(const ghc::filesystem::path& path,
+                                       int flags,
+                                       mode_t mode);
+
+Result<std::pair<ghc::filesystem::path, auto_fd>, std::string> open_temp_file(
     const ghc::filesystem::path& pattern);
 
 Result<std::string, std::string> read_file(const ghc::filesystem::path& path);

src/base/network.tcp.cc

@@ -66,7 +66,7 @@ connect(const char* hostname, const char* servname)
                                strerror(rc)));
     }
 
-    return Ok(retval);
+    return Ok(std::move(retval));
 }
 
 }  // namespace tcp

src/base/result.h

@@ -770,25 +770,29 @@ struct Result {
         return !ok_;
     }
 
-    T expect(const char* str) const {
+    T expect(const char* str)
+    {
         if (!isOk()) {
             ::fprintf(stderr, "%s\n", str);
-            std::terminate(); 
+            std::terminate();
         }
         return expect_impl(std::is_same<T, void>());
     }
 
     template<typename Func>
-    auto map(Func func) const {
+    auto map(Func func)
+    {
         using return_type = decltype(func(T{}));
 
         if (this->isOk()) {
-            auto value = this->storage().template get<T>();
+            auto value = std::move(this->storage().template get<T>());
-            auto res = func(value);
+            auto res = func(std::move(value));
-            return Result<return_type, E>(types::Ok<return_type>(std::move(res)));
+            return Result<return_type, E>(
+                types::Ok<return_type>(std::move(res)));
         }
 
-        return Result<return_type, E>(types::Err<E>(this->storage().template get<E>()));
+        return Result<return_type, E>(
+            types::Err<E>(this->storage().template get<E>()));
     }
 
     template<typename Func,
@@ -901,11 +905,9 @@ struct Result {
     }
 
     template<typename U = T>
-    typename std::enable_if<
+    typename std::enable_if<std::is_same<U, void>::value, U>::type unwrap()
-        std::is_same<U, void>::value,
+        const
-        U
+    {
-    >::type
-    unwrap() const {
         if (isOk()) {
             return;
         }
@@ -914,7 +916,8 @@ struct Result {
         std::terminate();
     }
 
-    E unwrapErr() const {
+    E unwrapErr() const
+    {
         if (isErr()) {
             return storage().template get<E>();
         }
@@ -924,8 +927,11 @@ struct Result {
     }
 
 private:
-    T expect_impl(std::true_type) const { }
+    T expect_impl(std::true_type) const {}
-    T expect_impl(std::false_type) const { return storage_.template get<T>(); }
+    T expect_impl(std::false_type)
+    {
+        return std::move(storage_.template get<T>());
+    }
 
     bool ok_;
     storage_type storage_;

src/bookmarks.cc

@@ -33,6 +33,4 @@
 
 #include "config.h"
 
-using namespace std;
+std::set<std::string> bookmark_metadata::KNOWN_TAGS;
-
-set<string> bookmark_metadata::KNOWN_TAGS;

src/command_executor.cc

@@ -47,11 +47,9 @@
 #include "sql_util.hh"
 #include "yajlpp/json_ptr.hh"
 
-using namespace std;
-
 exec_context INIT_EXEC_CONTEXT;
 
-static const string MSG_FORMAT_STMT = R"(
+static const std::string MSG_FORMAT_STMT = R"(
 SELECT count(*) AS total, min(log_line) AS log_line, log_msg_format
     FROM all_logs
     GROUP BY log_msg_format
@@ -103,16 +101,17 @@ sql_progress_finished()
     lnav_data.ld_views[LNV_DB].redo_search();
 }
 
-Result<string, string> execute_from_file(exec_context& ec,
+Result<std::string, std::string> execute_from_file(
-                                         const ghc::filesystem::path& path,
+    exec_context& ec,
-                                         int line_number,
+    const ghc::filesystem::path& path,
-                                         char mode,
+    int line_number,
-                                         const string& cmdline);
+    char mode,
+    const std::string& cmdline);
 
-Result<string, string>
+Result<std::string, std::string>
-execute_command(exec_context& ec, const string& cmdline)
+execute_command(exec_context& ec, const std::string& cmdline)
 {
-    vector<string> args;
+    std::vector<std::string> args;
 
     log_info("Executing: %s", cmdline.c_str());
 
@@ -131,14 +130,14 @@ execute_command(exec_context& ec, const string& cmdline)
     return ec.make_error("no command to execute");
 }
 
-Result<string, string>
+Result<std::string, std::string>
-execute_sql(exec_context& ec, const string& sql, string& alt_msg)
+execute_sql(exec_context& ec, const std::string& sql, std::string& alt_msg)
 {
     db_label_source& dls = lnav_data.ld_db_row_source;
     auto_mem<sqlite3_stmt> stmt(sqlite3_finalize);
     struct timeval start_tv, end_tv;
-    string stmt_str = trim(sql);
+    std::string stmt_str = trim(sql);
-    string retval;
+    std::string retval;
     int retcode;
 
     log_info("Executing SQL: %s", sql.c_str());
@@ -146,7 +145,7 @@ execute_sql(exec_context& ec, const string& sql, string& alt_msg)
     lnav_data.ld_bottom_source.grep_error("");
 
     if (startswith(stmt_str, ".")) {
-        vector<string> args;
+        std::vector<std::string> args;
         split_ws(stmt_str, args);
 
         auto sql_cmd_map = injector::get<readline_context::command_map_t*,
@@ -164,7 +163,7 @@ execute_sql(exec_context& ec, const string& sql, string& alt_msg)
 
     ec.ec_accumulator->clear();
 
-    pair<string, int> source = ec.ec_source.top();
+    std::pair<std::string, int> source = ec.ec_source.top();
     sql_progress_guard progress_guard(
         sql_progress, sql_progress_finished, source.first, source.second);
     gettimeofday(&start_tv, nullptr);
@@ -193,7 +192,7 @@ execute_sql(exec_context& ec, const string& sql, string& alt_msg)
 
         param_count = sqlite3_bind_parameter_count(stmt.in());
         for (int lpc = 0; lpc < param_count; lpc++) {
-            map<string, string>::iterator ov_iter;
+            std::map<std::string, std::string>::iterator ov_iter;
             const char* name;
 
             name = sqlite3_bind_parameter_name(stmt.in(), lpc + 1);
@@ -207,7 +206,8 @@ execute_sql(exec_context& ec, const string& sql, string& alt_msg)
             } else if (name[0] == '$') {
                 const auto& lvars = ec.ec_local_vars.top();
                 const auto& gvars = ec.ec_global_vars;
-                map<string, string>::const_iterator local_var, global_var;
+                std::map<std::string, std::string>::const_iterator local_var,
+                    global_var;
                 const char* env_value;
 
                 if (lnav_data.ld_window) {
@@ -409,7 +409,7 @@ execute_sql(exec_context& ec, const string& sql, string& alt_msg)
     return Ok(retval);
 }
 
-static Result<string, string>
+static Result<std::string, std::string>
 execute_file_contents(exec_context& ec,
                       const ghc::filesystem::path& path,
                       bool multiline)
@@ -417,7 +417,7 @@ execute_file_contents(exec_context& ec,
     static ghc::filesystem::path stdin_path("-");
     static ghc::filesystem::path dev_stdin_path("/dev/stdin");
 
-    string retval;
+    std::string retval;
     FILE* file;
 
     if (path == stdin_path || path == dev_stdin_path) {
@@ -433,7 +433,7 @@ execute_file_contents(exec_context& ec,
     auto_mem<char> line;
     size_t line_max_size;
     ssize_t line_size;
-    string cmdline;
+    std::string cmdline;
     char mode = '\0';
 
     ec.ec_path_stack.emplace_back(path.parent_path());
@@ -460,7 +460,7 @@ execute_file_contents(exec_context& ec,
 
                 starting_line_number = line_number;
                 mode = line[0];
-                cmdline = string(&line[1]);
+                cmdline = std::string(&line[1]);
                 break;
             default:
                 if (multiline) {
@@ -490,12 +490,12 @@ execute_file_contents(exec_context& ec,
     return Ok(retval);
 }
 
-Result<string, string>
+Result<std::string, std::string>
-execute_file(exec_context& ec, const string& path_and_args, bool multiline)
+execute_file(exec_context& ec, const std::string& path_and_args, bool multiline)
 {
     available_scripts scripts;
-    vector<string> split_args;
+    std::vector<std::string> split_args;
-    string retval, msg;
+    std::string retval, msg;
     shlex lexer(path_and_args);
 
     log_info("Executing file: %s", path_and_args.c_str());
@@ -512,7 +512,7 @@ execute_file(exec_context& ec, const string& path_and_args, bool multiline)
     auto script_name = split_args[0];
     auto& vars = ec.ec_local_vars.top();
     char env_arg_name[32];
-    string star, open_error = "file not found";
+    std::string star, open_error = "file not found";
 
     add_ansi_vars(vars);
 
@@ -532,7 +532,7 @@ execute_file(exec_context& ec, const string& path_and_args, bool multiline)
     }
     vars["__all__"] = star;
 
-    vector<script_metadata> paths_to_exec;
+    std::vector<script_metadata> paths_to_exec;
 
     find_format_scripts(lnav_data.ld_config_paths, scripts);
     auto iter = scripts.as_scripts.find(script_name);
@@ -583,14 +583,14 @@ execute_file(exec_context& ec, const string& path_and_args, bool multiline)
     return Ok(retval);
 }
 
-Result<string, string>
+Result<std::string, std::string>
 execute_from_file(exec_context& ec,
                   const ghc::filesystem::path& path,
                   int line_number,
                   char mode,
-                  const string& cmdline)
+                  const std::string& cmdline)
 {
-    string retval, alt_msg;
+    std::string retval, alt_msg;
     auto _sg = ec.enter_source(path.string(), line_number);
 
     switch (mode) {
@@ -621,10 +621,10 @@ execute_from_file(exec_context& ec,
     return Ok(retval);
 }
 
-Result<string, string>
+Result<std::string, std::string>
-execute_any(exec_context& ec, const string& cmdline_with_mode)
+execute_any(exec_context& ec, const std::string& cmdline_with_mode)
 {
-    string retval, alt_msg, cmdline = cmdline_with_mode.substr(1);
+    std::string retval, alt_msg, cmdline = cmdline_with_mode.substr(1);
     auto _cleanup = finally([&ec] {
         if (ec.is_read_write() &&
             // only rebuild in a script or non-interactive mode so we don't
@@ -661,8 +661,9 @@ execute_any(exec_context& ec, const string& cmdline_with_mode)
 }
 
 void
-execute_init_commands(exec_context& ec,
+execute_init_commands(
-                      vector<pair<Result<string, string>, string> >& msgs)
+    exec_context& ec,
+    std::vector<std::pair<Result<std::string, std::string>, std::string>>& msgs)
 {
     if (lnav_data.ld_cmd_init_done) {
         return;
@@ -673,7 +674,7 @@ execute_init_commands(exec_context& ec,
 
     log_info("Executing initial commands");
     for (auto& cmd : lnav_data.ld_commands) {
-        string alt_msg;
+        std::string alt_msg;
 
         wait_for_children();
 
@@ -705,9 +706,10 @@ execute_init_commands(exec_context& ec,
 
     if (!lnav_data.ld_pt_search.empty()) {
 #ifdef HAVE_LIBCURL
-        auto pt = make_shared<papertrail_proc>(lnav_data.ld_pt_search.substr(3),
+        auto pt = std::make_shared<papertrail_proc>(
-                                               lnav_data.ld_pt_min_time,
+            lnav_data.ld_pt_search.substr(3),
-                                               lnav_data.ld_pt_max_time);
+            lnav_data.ld_pt_min_time,
+            lnav_data.ld_pt_max_time);
         lnav_data.ld_active_files.fc_file_names[lnav_data.ld_pt_search].with_fd(
             pt->copy_fd());
         isc::to<curl_looper&, services::curl_streamer_t>().send(
@@ -744,7 +746,7 @@ sql_callback(exec_context& ec, sqlite3_stmt* stmt)
     if (dls.dls_headers.empty()) {
         for (lpc = 0; lpc < ncols; lpc++) {
             int type = sqlite3_column_type(stmt, lpc);
-            string colname = sqlite3_column_name(stmt, lpc);
+            std::string colname = sqlite3_column_name(stmt, lpc);
             bool graphable;
 
             graphable = ((type == SQLITE_INTEGER || type == SQLITE_FLOAT)
@@ -782,8 +784,8 @@ sql_callback(exec_context& ec, sqlite3_stmt* stmt)
     return retval;
 }
 
-future<string>
+std::future<std::string>
-pipe_callback(exec_context& ec, const string& cmdline, auto_fd& fd)
+pipe_callback(exec_context& ec, const std::string& cmdline, auto_fd& fd)
 {
     auto out = ec.get_output();
 
@@ -802,21 +804,20 @@ pipe_callback(exec_context& ec, const string& cmdline, auto_fd& fd)
                 fwrite(buffer, rc, 1, file);
             }
 
-            return string();
+            return std::string();
         });
     } else {
-        auto pp = make_shared<piper_proc>(
+        auto tmp_fd
-            fd,
+            = lnav::filesystem::open_temp_file(
-            false,
+                  ghc::filesystem::temp_directory_path() / "lnav.out.XXXXXX")
-            lnav::filesystem::open_temp_file(
+                  .map([](auto pair) {
-                ghc::filesystem::temp_directory_path() / "lnav.out.XXXXXX")
+                      ghc::filesystem::remove(pair.first);
-                .map([](auto pair) {
-                    ghc::filesystem::remove(pair.first);
 
-                    return pair;
+                      return std::move(pair.second);
-                })
+                  })
-                .expect("Cannot create temporary file for callback")
+                  .expect("Cannot create temporary file for callback");
-                .second);
+        auto pp = std::make_shared<piper_proc>(
+            std::move(fd), false, std::move(tmp_fd));
         static int exec_count = 0;
 
         lnav_data.ld_pipers.push_back(pp);
@@ -841,7 +842,7 @@ add_global_vars(exec_context& ec)
 {
     for (const auto& iter : lnav_config.lc_global_vars) {
         shlex subber(iter.second);
-        string str;
+        std::string str;
 
         if (!subber.eval(str, ec.ec_global_vars)) {
             log_error("Unable to evaluate global variable value: %s",
@@ -867,7 +868,9 @@ exec_context::get_error_prefix()
 }
 
 void
-exec_context::set_output(const string& name, FILE* file, int (*closer)(FILE*))
+exec_context::set_output(const std::string& name,
+                         FILE* file,
+                         int (*closer)(FILE*))
 {
     log_info("redirecting command output to: %s", name.c_str());
     this->ec_output_stack.back().second | [](auto out) {

src/command_executor.hh

@@ -36,7 +36,7 @@
 
 #include <sqlite3.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "bookmarks.hh"
 #include "fmt/format.h"
 #include "ghc/filesystem.hpp"
@@ -48,12 +48,11 @@ struct exec_context;
 class attr_line_t;
 class logline_value;
 
-typedef int (*sql_callback_t)(exec_context& ec, sqlite3_stmt* stmt);
+using sql_callback_t = int (*)(exec_context&, sqlite3_stmt*);
 int sql_callback(exec_context& ec, sqlite3_stmt* stmt);
 
-typedef std::future<std::string> (*pipe_callback_t)(exec_context& ec,
+using pipe_callback_t
-                                                    const std::string& cmdline,
+    = std::future<std::string> (*)(exec_context&, const std::string&, auto_fd&);
-                                                    auto_fd& fd);
 
 struct exec_context {
     enum class perm_t {

src/curl_looper.cc

@@ -38,7 +38,7 @@
 
 #    include "curl_looper.hh"
 
-using namespace std;
+using namespace std::chrono_literals;
 
 struct curl_request_eq {
     explicit curl_request_eq(const std::string& name) : cre_name(name){};
@@ -49,7 +49,7 @@ struct curl_request_eq {
     };
 
     bool operator()(
-        const pair<mstime_t, std::shared_ptr<curl_request>>& pair) const
+        const std::pair<mstime_t, std::shared_ptr<curl_request>>& pair) const
     {
         return this->cre_name == pair.second->get_name();
     };

src/data_parser.cc

@@ -34,8 +34,6 @@
 #include "config.h"
 #include "spookyhash/SpookyV2.h"
 
-using namespace std;
-
 data_format data_parser::FORMAT_SEMI("semi", DT_COMMA, DT_SEMI);
 data_format data_parser::FORMAT_COMMA("comma", DT_INVALID, DT_COMMA);
 data_format data_parser::FORMAT_PLAIN("plain", DT_INVALID, DT_INVALID);

src/data_scanner.cc

@@ -36,8 +36,6 @@
 #include "config.h"
 #include "pcrepp/pcrepp.hh"
 
-using namespace std;
-
 static struct {
     const char* name;
     pcrepp pcre;

src/elem_to_json.cc

@@ -34,8 +34,6 @@
 #include "config.h"
 #include "yajlpp/yajlpp.hh"
 
-using namespace std;
-
 static void
 element_to_json(yajl_gen gen, data_parser& dp, const data_parser::element& elem)
 {
@@ -54,7 +52,7 @@ element_to_json(yajl_gen gen, data_parser& dp, const data_parser::element& elem)
         }
         case DNT_PAIR: {
             const data_parser::element& pair_elem = elem.get_pair_elem();
-            string key_str
+            const auto key_str
                 = dp.get_element_string(pair_elem.e_sub_elements->front());
 
             if (!key_str.empty()) {
@@ -137,10 +135,10 @@ map_elements_to_json(yajl_gen gen,
                      data_parser::element_list_t* el)
 {
     bool unique_names = el->size() > 1;
-    vector<string> names;
+    std::vector<std::string> names;
 
     for (auto& iter : *el) {
-        const data_parser::element& pvalue = iter.get_pair_value();
+        const auto& pvalue = iter.get_pair_value();
 
         if (pvalue.value_token() == DT_INVALID) {
             log_debug("invalid!!");

src/environ_vtab.cc

@@ -36,8 +36,6 @@
 #include "base/lnav_log.hh"
 #include "config.h"
 
-using namespace std;
-
 extern char** environ;
 
 const char* const ENVIRON_CREATE_STMT = R"(

src/field_overlay_source.cc

@@ -40,8 +40,6 @@
 #include "vtab_module.hh"
 #include "vtab_module_json.hh"
 
-using namespace std;
-
 json_string extract(const char* str);
 
 void
@@ -65,7 +63,7 @@ field_overlay_source::build_summary_lines(const listview_curses& lv)
         if (free_rows < 2 || !this->fos_show_status) {
             this->fos_summary_lines.clear();
         } else {
-            string time_span;
+            std::string time_span;
             double error_rate = 0.0;
 
             if (lv.get_inner_height() == 0) {
@@ -130,7 +128,7 @@ field_overlay_source::build_summary_lines(const listview_curses& lv)
                                 long computed_rate_len
                                     = lrint(ceil((recent_error_rate * 40.0)
                                                  / long_error_rate));
-                                rate_len = min(10L, computed_rate_len);
+                                rate_len = std::min(10L, computed_rate_len);
                             }
                         }
                     }
@@ -164,7 +162,7 @@ field_overlay_source::build_summary_lines(const listview_curses& lv)
                     error_rate,
                     time_span.c_str());
             }
-            string& sum_msg = sum_line.get_string();
+            const auto& sum_msg = sum_line.get_string();
             sum_line
                 .with_attr(string_attr(
                     line_range(sum_msg.find("Error rate"),
@@ -248,7 +246,7 @@ field_overlay_source::build_field_lines(const listview_curses& lv)
     char old_timestamp[64], curr_timestamp[64], orig_timestamp[64];
     struct timeval curr_tv, offset_tv, orig_tv, diff_tv = {0, 0};
     attr_line_t time_line;
-    string& time_str = time_line.get_string();
+    auto& time_str = time_line.get_string();
     struct line_range time_lr;
 
     sql_strftime(curr_timestamp,
@@ -368,7 +366,8 @@ field_overlay_source::build_field_lines(const listview_curses& lv)
         if (!meta.lvm_struct_name.empty()) {
             this_key_size += meta.lvm_struct_name.size() + 11;
         }
-        this->fos_known_key_size = max(this->fos_known_key_size, this_key_size);
+        this->fos_known_key_size
+            = std::max(this->fos_known_key_size, this_key_size);
     }
 
     for (auto iter = this->fos_log_helper.ldh_parser->dp_pairs.begin();
@@ -381,7 +380,7 @@ field_overlay_source::build_field_lines(const listview_curses& lv)
 
         colname = this->fos_log_helper.ldh_namer->add_column(colname);
         this->fos_unknown_key_size
-            = max(this->fos_unknown_key_size, (int) colname.length());
+            = std::max(this->fos_unknown_key_size, (int) colname.length());
     }
 
     auto lf = this->fos_log_helper.ldh_file->get_format();
@@ -408,9 +407,9 @@ field_overlay_source::build_field_lines(const listview_curses& lv)
 
         auto curr_format = lv.lv_meta.lvm_format.value();
         auto curr_elf = dynamic_cast<external_log_format*>(curr_format);
-        string format_name = curr_format->get_name().to_string();
+        const auto format_name = curr_format->get_name().to_string();
         attr_line_t al;
-        string str, value_str = lv.to_string();
+        std::string str, value_str = lv.to_string();
 
         if (curr_format != last_format) {
             this->fos_lines.emplace_back(" Known message fields for table "

src/file_collection.cc

@@ -158,8 +158,9 @@ file_collection::merge(file_collection& other)
                                  other.fc_synced_files.end());
     this->fc_name_to_errors.insert(other.fc_name_to_errors.begin(),
                                    other.fc_name_to_errors.end());
-    this->fc_file_names.insert(other.fc_file_names.begin(),
+    this->fc_file_names.insert(
-                               other.fc_file_names.end());
+        std::make_move_iterator(other.fc_file_names.begin()),
+        std::make_move_iterator(other.fc_file_names.end()));
     if (!other.fc_files.empty()) {
         for (const auto& lf : other.fc_files) {
             this->fc_name_to_errors.erase(lf->get_filename());
@@ -229,6 +230,15 @@ file_collection::watch_logfile(const std::string& filename,
 
     if (loo.loo_fd != -1) {
         rc = fstat(loo.loo_fd, &st);
+        if (rc == 0) {
+            loo.with_stat_for_temp(st);
+        }
+    } else if (loo.loo_temp_file) {
+        memset(&st, 0, sizeof(st));
+        st.st_dev = loo.loo_temp_dev;
+        st.st_ino = loo.loo_temp_ino;
+        st.st_mode = S_IFREG;
+        rc = 0;
     } else {
         rc = stat(filename.c_str(), &st);
     }
@@ -292,7 +302,7 @@ file_collection::watch_logfile(const std::string& filename,
 
         auto func = [filename,
                      st,
-                     loo,
+                     loo2 = std::move(loo),
                      prog = this->fc_progress,
                      errs = this->fc_name_to_errors]() mutable {
             file_collection retval;
@@ -304,7 +314,7 @@ file_collection::watch_logfile(const std::string& filename,
 
             auto ff = detect_file_format(filename);
 
-            loo.loo_file_format = ff;
+            loo2.loo_file_format = ff;
             switch (ff) {
                 case file_format_t::SQLITE_DB:
                     retval.fc_other_files[filename].ofd_format = ff;
@@ -316,7 +326,7 @@ file_collection::watch_logfile(const std::string& filename,
                     if (res.isOk()) {
                         auto convert_res = res.unwrap();
 
-                        loo.loo_fd = std::move(convert_res.cr_destination);
+                        loo2.with_fd(std::move(convert_res.cr_destination));
                         retval.fc_child_pollers.emplace_back(child_poller{
                             std::move(convert_res.cr_child),
                             [filename,
@@ -342,7 +352,7 @@ file_collection::watch_logfile(const std::string& filename,
                                     });
                             },
                         });
-                        auto open_res = logfile::open(filename, loo);
+                        auto open_res = logfile::open(filename, loo2);
                         if (open_res.isOk()) {
                             retval.fc_files.push_back(open_res.unwrap());
                         } else {
@@ -368,7 +378,7 @@ file_collection::watch_logfile(const std::string& filename,
                         std::list<archive_manager::extract_progress>::iterator>
                         prog_iter_opt;
 
-                    if (loo.loo_source == logfile_name_source::ARCHIVE) {
+                    if (loo2.loo_source == logfile_name_source::ARCHIVE) {
                         // Don't try to open nested archives
                         return retval;
                     }
@@ -435,7 +445,7 @@ file_collection::watch_logfile(const std::string& filename,
                 default:
                     log_info("loading new file: filename=%s", filename.c_str());
 
-                    auto open_res = logfile::open(filename, loo);
+                    auto open_res = logfile::open(filename, loo2);
                     if (open_res.isOk()) {
                         retval.fc_files.push_back(open_res.unwrap());
                     } else {
@@ -452,16 +462,16 @@ file_collection::watch_logfile(const std::string& filename,
             return retval;
         };
 
-        return std::async(std::launch::async, func);
+        return std::async(std::launch::async, std::move(func));
-    } else {
+    }
-        auto lf = *file_iter;
 
-        if (lf->is_valid_filename() && lf->get_filename() != filename) {
+    auto lf = *file_iter;
-            /* The file is already loaded, but has been found under a different
+
-             * name.  We just need to update the stored file name.
+    if (lf->is_valid_filename() && lf->get_filename() != filename) {
-             */
+        /* The file is already loaded, but has been found under a different
-            retval.fc_renamed_files.emplace_back(lf, filename);
+         * name.  We just need to update the stored file name.
-        }
+         */
+        retval.fc_renamed_files.emplace_back(lf, filename);
     }
 
     return lnav::futures::make_ready_future(std::move(retval));
@@ -513,9 +523,12 @@ file_collection::expand_filename(
                     }
 
                     file_collection retval;
+                    logfile_open_options_base loo_base{loo};
 
                     isc::to<tailer::looper&, services::remote_tailer_t>().send(
-                        [=](auto& tlooper) { tlooper.add_remote(rp, loo); });
+                        [rp, loo_base](auto& tlooper) {
+                            tlooper.add_remote(rp, loo_base);
+                        });
                     retval.fc_other_files[path] = file_format_t::REMOTE;
                     {
                         this->fc_progress->writeAccess()
@@ -546,7 +559,7 @@ file_collection::expand_filename(
 
                 if ((abspath = realpath(gl->gl_pathv[lpc], nullptr)) == nullptr)
                 {
-                    auto errmsg = strerror(errno);
+                    auto* errmsg = strerror(errno);
 
                     if (required) {
                         fprintf(stderr,
@@ -576,11 +589,11 @@ file_collection::expand_filename(
                             std::move(retval)));
                     }
                     continue;
-                } else {
-                    auto p = REALPATH_CACHE.emplace(path_str, abspath.in());
-
-                    iter = p.first;
                 }
+
+                auto p = REALPATH_CACHE.emplace(path_str, abspath.in());
+
+                iter = p.first;
             }
 
             if (required || access(iter->second.c_str(), R_OK) == 0) {
@@ -598,7 +611,7 @@ file_collection::rescan_files(bool required)
         [&retval](auto& fc) { retval.merge(fc); });
 
     for (auto& pair : this->fc_file_names) {
-        if (pair.second.loo_fd == -1) {
+        if (!pair.second.loo_temp_file) {
             this->expand_filename(fq, pair.first, pair.second, required);
             if (this->fc_rotated) {
                 std::string path = pair.first + ".*";

src/file_format.cc

@@ -34,7 +34,7 @@
 #include "file_format.hh"
 
 #include "archive_manager.hh"
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/fs_util.hh"
 #include "base/intern_string.hh"
 #include "base/lnav_log.hh"

src/file_vtab.cc

@@ -41,10 +41,8 @@
 #include "session_data.hh"
 #include "vtab_module.hh"
 
-using namespace std;
-
 struct lnav_file : public tvt_iterator_cursor<lnav_file> {
-    using iterator = vector<shared_ptr<logfile>>::iterator;
+    using iterator = std::vector<std::shared_ptr<logfile>>::iterator;
 
     static constexpr const char* NAME = "lnav_file";
     static constexpr const char* CREATE_STMT = R"(
@@ -78,7 +76,7 @@ CREATE TABLE lnav_file (
     {
         auto lf = *vc.iter;
         const struct stat& st = lf->get_stat();
-        const string& name = lf->get_filename();
+        const auto& name = lf->get_filename();
         auto format = lf->get_format();
         const char* format_name = format != nullptr ? format->get_name().get()
                                                     : nullptr;

src/filter_sub_source.cc

@@ -37,8 +37,6 @@
 #include "readline_highlighters.hh"
 #include "readline_possibilities.hh"
 
-using namespace std;
-
 filter_sub_source::filter_sub_source()
 {
     this->fss_regex_context.set_highlighter(readline_regex_highlighter)
@@ -97,7 +95,7 @@ filter_sub_source::list_input_handle_key(listview_curses& lv, int ch)
                 return true;
             }
 
-            shared_ptr<text_filter> tf = *(fs.begin() + lv.get_selection());
+            auto tf = *(fs.begin() + lv.get_selection());
 
             fs.set_filter_enabled(tf, !tf->is_enabled());
             tss->text_filters_changed();
@@ -113,7 +111,7 @@ filter_sub_source::list_input_handle_key(listview_curses& lv, int ch)
                 return true;
             }
 
-            shared_ptr<text_filter> tf = *(fs.begin() + lv.get_selection());
+            auto tf = *(fs.begin() + lv.get_selection());
 
             if (tf->get_type() == text_filter::INCLUDE) {
                 tf->set_type(text_filter::EXCLUDE);
@@ -134,7 +132,7 @@ filter_sub_source::list_input_handle_key(listview_curses& lv, int ch)
                 return true;
             }
 
-            shared_ptr<text_filter> tf = *(fs.begin() + lv.get_selection());
+            auto tf = *(fs.begin() + lv.get_selection());
 
             fs.delete_filter(tf->get_id());
             lv.reload_data();
@@ -153,8 +151,8 @@ filter_sub_source::list_input_handle_key(listview_curses& lv, int ch)
                 return true;
             }
 
-            auto ef = make_shared<empty_filter>(text_filter::type_t::INCLUDE,
+            auto ef = std::make_shared<empty_filter>(
-                                                *filter_index);
+                text_filter::type_t::INCLUDE, *filter_index);
             fs.add_filter(ef);
             lv.set_selection(vis_line_t(fs.size() - 1));
             lv.reload_data();
@@ -190,8 +188,8 @@ filter_sub_source::list_input_handle_key(listview_curses& lv, int ch)
                 return true;
             }
 
-            auto ef = make_shared<empty_filter>(text_filter::type_t::EXCLUDE,
+            auto ef = std::make_shared<empty_filter>(
-                                                *filter_index);
+                text_filter::type_t::EXCLUDE, *filter_index);
             fs.add_filter(ef);
             lv.set_selection(vis_line_t(fs.size() - 1));
             lv.reload_data();
@@ -225,7 +223,7 @@ filter_sub_source::list_input_handle_key(listview_curses& lv, int ch)
                 return true;
             }
 
-            shared_ptr<text_filter> tf = *(fs.begin() + lv.get_selection());
+            auto tf = *(fs.begin() + lv.get_selection());
 
             this->fss_editing = true;
 
@@ -309,7 +307,7 @@ filter_sub_source::text_value_for_line(textview_curses& tc,
     textview_curses* top_view = *lnav_data.ld_view_stack.top();
     text_sub_source* tss = top_view->get_sub_source();
     filter_stack& fs = tss->get_filters();
-    shared_ptr<text_filter> tf = *(fs.begin() + line);
+    auto tf = *(fs.begin() + line);
 
     value_out = "    ";
     switch (tf->get_type()) {
@@ -349,7 +347,7 @@ filter_sub_source::text_attrs_for_line(textview_curses& tc,
     textview_curses* top_view = *lnav_data.ld_view_stack.top();
     text_sub_source* tss = top_view->get_sub_source();
     filter_stack& fs = tss->get_filters();
-    shared_ptr<text_filter> tf = *(fs.begin() + line);
+    auto tf = *(fs.begin() + line);
     bool selected
         = lnav_data.ld_mode == LNM_FILTER && line == tc.get_selection();
 
@@ -410,7 +408,7 @@ filter_sub_source::text_size_for_line(textview_curses& tc,
     textview_curses* top_view = *lnav_data.ld_view_stack.top();
     text_sub_source* tss = top_view->get_sub_source();
     filter_stack& fs = tss->get_filters();
-    shared_ptr<text_filter> tf = *(fs.begin() + line);
+    auto tf = *(fs.begin() + line);
 
     return 8 + tf->get_id().size();
 }
@@ -426,8 +424,8 @@ filter_sub_source::rl_change(readline_curses* rc)
     }
 
     auto iter = fs.begin() + this->tss_view->get_selection();
-    shared_ptr<text_filter> tf = *iter;
+    auto tf = *iter;
-    string new_value = rc->get_line_buffer();
+    auto new_value = rc->get_line_buffer();
 
     switch (tf->get_lang()) {
         case filter_lang_t::NONE:
@@ -507,8 +505,8 @@ filter_sub_source::rl_perform(readline_curses* rc)
     text_sub_source* tss = top_view->get_sub_source();
     filter_stack& fs = tss->get_filters();
     auto iter = fs.begin() + this->tss_view->get_selection();
-    shared_ptr<text_filter> tf = *iter;
+    auto tf = *iter;
-    string new_value = rc->get_value();
+    auto new_value = rc->get_value();
 
     if (new_value.empty()) {
         this->rl_abort(rc);
@@ -534,10 +532,10 @@ filter_sub_source::rl_perform(readline_curses* rc)
                     tf->lf_deleted = true;
                     tss->text_filters_changed();
 
-                    auto pf = make_shared<pcre_filter>(tf->get_type(),
+                    auto pf = std::make_shared<pcre_filter>(tf->get_type(),
-                                                       new_value,
+                                                            new_value,
-                                                       tf->get_index(),
+                                                            tf->get_index(),
-                                                       code.release());
+                                                            code.release());
 
                     *iter = pf;
                     tss->text_filters_changed();
@@ -588,7 +586,7 @@ filter_sub_source::rl_abort(readline_curses* rc)
     text_sub_source* tss = top_view->get_sub_source();
     filter_stack& fs = tss->get_filters();
     auto iter = fs.begin() + this->tss_view->get_selection();
-    shared_ptr<text_filter> tf = *iter;
+    auto tf = *iter;
 
     lnav_data.ld_log_source.set_preview_sql_filter(nullptr);
     lnav_data.ld_filter_help_status_source.fss_prompt.clear();
@@ -616,7 +614,7 @@ filter_sub_source::rl_display_matches(readline_curses* rc)
         this->fss_match_view.set_height(0_vl);
         this->tss_view->set_needs_update();
     } else {
-        string current_match = rc->get_match_string();
+        auto current_match = rc->get_match_string();
         attr_line_t al;
         vis_line_t line, selected_line;
 

src/format2csv.py

@@ -15,6 +15,8 @@ def main(args):
                     value = format_dict[key]
                     if not isinstance(value, dict):
                         continue
+                    if 'title' not in value:
+                        raise Exception("format '%s' is missing 'title'" % key)
                     out.writerow((value['title'], key, value['description']))
 
 if __name__ == "__main__":

src/formats/pcap_log.json

@@ -2,14 +2,17 @@
     "$schema": "https://lnav.org/schemas/format-v1.schema.json",
     "pcap_log": {
         "json": true,
-        "description": "pcap log format",
+        "title": "Packet Capture",
+        "description": "Internal format for pcap files",
         "mime-types": [
             "application/vnd.tcpdump.pcap"
         ],
         "multiline": false,
         "convert-to-local-time": true,
         "line-format": [
-            { "field": "time" },
+            {
+                "field": "time"
+            },
             " ",
             {
                 "field": "source",
@@ -35,7 +38,9 @@
                 "align": "right"
             },
             " ",
-            { "field": "info" }
+            {
+                "field": "info"
+            }
         ],
         "level": {
             "warning": "^6291456$",

src/fs-extension-functions.cc

@@ -44,7 +44,6 @@
 #include "sqlite3.h"
 #include "vtab_module.hh"
 
-using namespace std;
 using namespace mapbox;
 
 static util::variant<const char*, string_fragment>
@@ -95,8 +94,8 @@ sql_dirname(const char* path_in)
     return path_in[0] == '/' ? "/" : ".";
 }
 
-static nonstd::optional<string>
+static nonstd::optional<std::string>
-sql_joinpath(const vector<const char*>& paths)
+sql_joinpath(const std::vector<const char*>& paths)
 {
     std::string full_path;
 
@@ -123,7 +122,7 @@ sql_joinpath(const vector<const char*>& paths)
     return full_path;
 }
 
-static string
+static std::string
 sql_readlink(const char* path)
 {
     struct stat st;
@@ -145,10 +144,10 @@ sql_readlink(const char* path)
             "unable to read link: {} -- {}", path, strerror(errno));
     }
 
-    return string(buf, rc);
+    return std::string(buf, rc);
 }
 
-static string
+static std::string
 sql_realpath(const char* path)
 {
     char resolved_path[PATH_MAX];

src/fstat_vtab.cc

@@ -41,8 +41,6 @@
 #include "sql_util.hh"
 #include "vtab_module.hh"
 
-using namespace std;
-
 enum {
     FSTAT_COL_PARENT,
     FSTAT_COL_NAME,
@@ -65,6 +63,9 @@ enum {
     FSTAT_COL_PATTERN,
 };
 
+/**
+ * @feature f0:sql.tables.fstat
+ */
 struct fstat_table {
     static constexpr const char* NAME = "fstat";
     static constexpr const char* CREATE_STMT = R"(
@@ -93,7 +94,7 @@ CREATE TABLE fstat (
 
     struct cursor {
         sqlite3_vtab_cursor base;
-        string c_pattern;
+        std::string c_pattern;
         static_root_mem<glob_t, globfree> c_glob;
         size_t c_path_index{0};
         struct stat c_stat;

src/grep_proc.cc

@@ -46,8 +46,6 @@
 #include "lnav_util.hh"
 #include "vis_line.hh"
 
-using namespace std;
-
 template<typename LineType>
 grep_proc<LineType>::grep_proc(pcre* code, grep_proc_source<LineType>& gps)
     : gp_pcre(code), gp_source(gps)
@@ -66,7 +64,7 @@ grep_proc<LineType>::~grep_proc()
 template<typename LineType>
 void
 grep_proc<LineType>::handle_match(
-    int line, string& line_value, int off, int* matches, int count)
+    int line, std::string& line_value, int off, int* matches, int count)
 {
     int lpc;
 
@@ -152,7 +150,7 @@ void
 grep_proc<LineType>::child_loop()
 {
     char outbuf[BUFSIZ * 2];
-    string line_value;
+    std::string line_value;
 
     /* Make sure buffering is on, not sure of the state in the parent. */
     if (setvbuf(stdout, outbuf, _IOFBF, BUFSIZ * 2) < 0) {

src/grep_proc.hh

@@ -42,7 +42,7 @@
 #include <string>
 #include <vector>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "auto_mem.hh"
 #include "base/lnav_log.hh"
 #include "line_buffer.hh"

src/hotkeys.cc

@@ -51,8 +51,6 @@
 #include "termios_guard.hh"
 #include "xterm_mouse.hh"
 
-using namespace std;
-
 class logline_helper {
 public:
     logline_helper(logfile_sub_source& lss)
@@ -101,14 +99,14 @@ public:
     {
         const char* start = this->lh_msg_buffer.get_data();
 
-        return string(&start[lr.lr_start], lr.length());
+        return std::string(&start[lr.lr_start], lr.length());
     }
 
     logfile_sub_source& lh_sub_source;
     vis_line_t lh_current_line;
     shared_buffer_ref lh_msg_buffer;
     string_attrs_t lh_string_attrs;
-    vector<logline_value> lh_line_values;
+    std::vector<logline_value> lh_line_values;
 };
 
 static int
@@ -133,7 +131,7 @@ key_sql_callback(exec_context& ec, sqlite3_stmt* stmt)
         }
 
         vars[column_name]
-            = string((const char*) sqlite3_column_text(stmt, lpc));
+            = std::string((const char*) sqlite3_column_text(stmt, lpc));
     }
 
     return 0;
@@ -149,12 +147,12 @@ handle_keyseq(const char* keyseq)
         return false;
     }
 
-    vector<logline_value> values;
+    std::vector<logline_value> values;
     exec_context ec(&values, key_sql_callback, pipe_callback);
     auto& var_stack = ec.ec_local_vars;
 
     ec.ec_global_vars = lnav_data.ld_exec_context.ec_global_vars;
-    var_stack.push(map<string, string>());
+    var_stack.push(std::map<std::string, std::string>());
     auto& vars = var_stack.top();
     vars["keyseq"] = keyseq;
     const auto& kc = iter->second;
@@ -166,7 +164,7 @@ handle_keyseq(const char* keyseq)
 
     if (!kc.kc_alt_msg.empty()) {
         shlex lexer(kc.kc_alt_msg);
-        string expanded_msg;
+        std::string expanded_msg;
 
         if (lexer.eval(expanded_msg,
                        {
@@ -339,7 +337,7 @@ handle_paging_key(int ch)
                 execute_command(
                     ec,
                     "zoom-to "
-                        + string(
+                        + std::string(
                             lnav_zoom_strings[lnav_data.ld_zoom_level - 1]));
             }
             break;
@@ -351,7 +349,7 @@ handle_paging_key(int ch)
                 execute_command(
                     ec,
                     "zoom-to "
-                        + string(
+                        + std::string(
                             lnav_zoom_strings[lnav_data.ld_zoom_level + 1]));
             }
             break;
@@ -424,10 +422,10 @@ handle_paging_key(int ch)
                 == lnav_data.ld_last_user_mark.end()) {
                 alerter::singleton().chime();
             } else {
-                int start_line = min((int) tc->get_top(),
+                int start_line = std::min((int) tc->get_top(),
-                                     lnav_data.ld_last_user_mark[tc] + 1);
+                                          lnav_data.ld_last_user_mark[tc] + 1);
-                int end_line = max((int) tc->get_top(),
+                int end_line = std::max((int) tc->get_top(),
-                                   lnav_data.ld_last_user_mark[tc] - 1);
+                                        lnav_data.ld_last_user_mark[tc] - 1);
 
                 tc->toggle_user_mark(&textview_curses::BM_USER,
                                      vis_line_t(start_line),
@@ -636,7 +634,8 @@ handle_paging_key(int ch)
                         lnav_data.ld_rl_view->set_value("");
                         tc->set_top(next_helper.lh_current_line);
                     } else {
-                        string opid_str = start_helper.to_string(opid_range);
+                        const auto opid_str
+                            = start_helper.to_string(opid_range);
 
                         lnav_data.ld_rl_view->set_value(err_prefix(
                             "No more messages found with opid: " + opid_str));
@@ -814,7 +813,7 @@ handle_paging_key(int ch)
                         lnav_data.ld_rl_view->set_value("Graphing all values");
                     },
                     [&](stacked_bar_chart_base::show_one) {
-                        string colname;
+                        std::string colname;
 
                         chart.get_ident_to_show(colname);
                         lnav_data.ld_rl_view->set_value(

src/line_buffer.cc

@@ -52,8 +52,6 @@
 #include "fmtlib/fmt/format.h"
 #include "line_buffer.hh"
 
-using namespace std;
-
 static const ssize_t DEFAULT_INCREMENT = 128 * 1024;
 static const ssize_t MAX_COMPRESSED_BUFFER_SIZE = 32 * 1024 * 1024;
 
@@ -126,7 +124,7 @@ read_le32(const unsigned char* data)
 line_buffer::gz_indexed::gz_indexed()
 {
     if ((this->inbuf = (Bytef*) malloc(Z_BUFSIZE)) == NULL) {
-        throw bad_alloc();
+        throw std::bad_alloc();
     }
 }
 
@@ -300,7 +298,7 @@ line_buffer::line_buffer()
       lb_last_line_offset(-1)
 {
     if ((this->lb_buffer = (char*) malloc(this->lb_buffer_max)) == nullptr) {
-        throw bad_alloc();
+        throw std::bad_alloc();
     }
 
     ensure(this->invariant());
@@ -548,7 +546,7 @@ line_buffer::fill_range(file_off_t start, ssize_t max_length)
                 if ((bz_file = BZ2_bzdopen(bzfd, "r")) == NULL) {
                     close(bzfd);
                     if (errno == 0) {
-                        throw bad_alloc();
+                        throw std::bad_alloc();
                     } else {
                         throw error(errno);
                     }
@@ -647,7 +645,7 @@ line_buffer::fill_range(file_off_t start, ssize_t max_length)
     return retval;
 }
 
-Result<line_info, string>
+Result<line_info, std::string>
 line_buffer::load_next_line(file_range prev_line)
 {
     ssize_t request_size = DEFAULT_INCREMENT;
@@ -780,11 +778,11 @@ line_buffer::read_range(const file_range fr)
          * Don't return anything past the last known line.  The caller needs
          * to try reading at the offset of the last line again.
          */
-        return Err(string("out-of-bounds"));
+        return Err(std::string("out-of-bounds"));
     }
 
     if (!this->fill_range(fr.fr_offset, fr.fr_size)) {
-        return Err(string("unable to read file"));
+        return Err(std::string("unable to read file"));
     }
     line_start = this->get_range(fr.fr_offset, avail);
 

src/line_buffer.hh

@@ -40,8 +40,8 @@
 #include <unistd.h>
 #include <zlib.h>
 
-#include "auto_fd.hh"
 #include "auto_mem.hh"
+#include "base/auto_fd.hh"
 #include "base/file_range.hh"
 #include "base/lnav_log.hh"
 #include "base/result.h"

src/listview_curses.cc

@@ -39,8 +39,6 @@
 #include "base/lnav_log.hh"
 #include "config.h"
 
-using namespace std;
-
 list_gutter_source listview_curses::DEFAULT_GUTTER_SOURCE;
 
 listview_curses::listview_curses() : lv_scroll(noop_func{}) {}
@@ -53,7 +51,8 @@ listview_curses::reload_data()
         this->lv_left = 0;
     } else {
         if (this->lv_top >= this->get_inner_height()) {
-            this->lv_top = max(0_vl, vis_line_t(this->get_inner_height() - 1));
+            this->lv_top
+                = std::max(0_vl, vis_line_t(this->get_inner_height() - 1));
         }
         if (this->get_inner_height() == 0) {
             this->lv_selection = 0_vl;
@@ -207,8 +206,8 @@ listview_curses::do_update()
         row_count = this->get_inner_height();
         row = this->lv_top;
         bottom = y + height;
-        vector<attr_line_t> rows(
+        std::vector<attr_line_t> rows(
-            min((size_t) height, row_count - (int) this->lv_top));
+            std::min((size_t) height, row_count - (int) this->lv_top));
         this->lv_source->listview_value_for_rows(*this, row, rows);
         while (y < bottom) {
             lr.lr_start = this->lv_left;
@@ -268,7 +267,7 @@ listview_curses::do_update()
 
             y = this->lv_y + (int) (progress * (double) height);
             lines = vis_line_t(
-                y + min((int) height, (int) (coverage * (double) height)));
+                y + std::min((int) height, (int) (coverage * (double) height)));
 
             for (unsigned int gutter_y = this->lv_y;
                  gutter_y < (this->lv_y + height);

src/lnav.cc

@@ -154,11 +154,10 @@
 #    define SYSCONFDIR "/usr/etc"
 #endif
 
-using namespace std;
 using namespace std::literals::chrono_literals;
 
 static bool initial_build = false;
-static multimap<lnav_flags_t, string> DEFAULT_FILES;
+static std::multimap<lnav_flags_t, std::string> DEFAULT_FILES;
 static auto intern_lifetime = intern_string::get_table_lifetime();
 
 struct lnav_data_t lnav_data;
@@ -377,7 +376,7 @@ setup_logline_table(exec_context& ec)
                 lnav_data.ld_rl_view->add_possibility(
                     LNM_SQL,
                     "*",
-                    string(func_def.zName) + (func_def.nArg ? "(" : "()"));
+                    std::string(func_def.zName) + (func_def.nArg ? "(" : "()"));
             }
             for (int lpc2 = 0; agg_funcs && agg_funcs[lpc2].zName; lpc2++) {
                 const FuncDefAgg& func_def = agg_funcs[lpc2];
@@ -385,7 +384,7 @@ setup_logline_table(exec_context& ec)
                 lnav_data.ld_rl_view->add_possibility(
                     LNM_SQL,
                     "*",
-                    string(func_def.zName) + (func_def.nArg ? "(" : "()"));
+                    std::string(func_def.zName) + (func_def.nArg ? "(" : "()"));
             }
         }
 
@@ -393,7 +392,7 @@ setup_logline_table(exec_context& ec)
             switch (pair.second->ht_context) {
                 case help_context_t::HC_SQL_FUNCTION:
                 case help_context_t::HC_SQL_TABLE_VALUED_FUNCTION: {
-                    string poss = pair.first
+                    std::string poss = pair.first
                         + (pair.second->ht_parameters.empty() ? "()" : ("("));
 
                     lnav_data.ld_rl_view->add_possibility(LNM_SQL, "*", poss);
@@ -423,7 +422,7 @@ class loading_observer : public logfile_observer {
 public:
     loading_observer() : lo_last_offset(0){};
 
-    indexing_result logfile_indexing(const shared_ptr<logfile>& lf,
+    indexing_result logfile_indexing(const std::shared_ptr<logfile>& lf,
                                      file_off_t off,
                                      file_size_t total) override
     {
@@ -452,7 +451,7 @@ public:
         return indexing_result::CONTINUE;
     };
 
-    static void do_update(const shared_ptr<logfile>& lf)
+    static void do_update(const std::shared_ptr<logfile>& lf)
     {
         if (isendwin()) {
             return;
@@ -546,7 +545,7 @@ class textfile_callback {
 public:
     textfile_callback() : front_file(nullptr), front_top(-1){};
 
-    void closed_files(const std::vector<shared_ptr<logfile>>& files)
+    void closed_files(const std::vector<std::shared_ptr<logfile>>& files)
     {
         for (const auto& lf : files) {
             log_info("closed text files: %s", lf->get_filename().c_str());
@@ -554,7 +553,7 @@ public:
         lnav_data.ld_active_files.close_files(files);
     };
 
-    void promote_file(const shared_ptr<logfile>& lf)
+    void promote_file(const std::shared_ptr<logfile>& lf)
     {
         if (lnav_data.ld_log_source.insert_file(lf)) {
             this->did_promotion = true;
@@ -584,7 +583,7 @@ public:
         }
     };
 
-    void scanned_file(const shared_ptr<logfile>& lf)
+    void scanned_file(const std::shared_ptr<logfile>& lf)
     {
         if (!lnav_data.ld_files_to_front.empty()
             && lnav_data.ld_files_to_front.front().first == lf->get_filename())
@@ -596,7 +595,7 @@ public:
         }
     };
 
-    shared_ptr<logfile> front_file;
+    std::shared_ptr<logfile> front_file;
     int front_top;
     bool did_promotion{false};
 };
@@ -679,7 +678,8 @@ rebuild_indexes(nonstd::optional<ui_clock::time_point> deadline)
         log_view.reload_data();
 
         {
-            unordered_map<string, list<shared_ptr<logfile>>> id_to_files;
+            std::unordered_map<std::string, std::list<std::shared_ptr<logfile>>>
+                id_to_files;
             bool reload = false;
 
             for (const auto& lf : lnav_data.ld_active_files.fc_files) {
@@ -751,14 +751,14 @@ append_default_files(lnav_flags_t flag)
     if (lnav_data.ld_flags & flag) {
         auto cwd = ghc::filesystem::current_path();
 
-        pair<multimap<lnav_flags_t, string>::iterator,
+        std::pair<std::multimap<lnav_flags_t, std::string>::iterator,
-             multimap<lnav_flags_t, string>::iterator>
+                  std::multimap<lnav_flags_t, std::string>::iterator>
             range;
         for (range = DEFAULT_FILES.equal_range(flag);
              range.first != range.second;
              range.first++)
         {
-            string path = range.first->second;
+            std::string path = range.first->second;
             struct stat st;
 
             if (access(path.c_str(), R_OK) == 0) {
@@ -1551,7 +1551,8 @@ looper()
             id.id_escape_matcher = match_escape_seq;
             id.id_escape_handler = handle_keyseq;
             id.id_key_handler = handle_key;
-            id.id_mouse_handler = bind(&xterm_mouse::handle_mouse, &mouse_i);
+            id.id_mouse_handler
+                = std::bind(&xterm_mouse::handle_mouse, &mouse_i);
             id.id_unhandled_handler = [](const char* keyseq) {
                 auto enc_len = lnav_config.lc_ui_keymap.size() * 2;
                 auto encoded_name = (char*) alloca(enc_len);
@@ -1589,7 +1590,7 @@ looper()
         log_debug("rescan started %p", &active_copy);
         active_copy.merge(lnav_data.ld_active_files);
         active_copy.fc_progress = lnav_data.ld_active_files.fc_progress;
-        future<file_collection> rescan_future
+        std::future<file_collection> rescan_future
             = std::async(std::launch::async,
                          &file_collection::rescan_files,
                          std::move(active_copy),
@@ -1607,7 +1608,7 @@ looper()
             auto loop_deadline
                 = ui_clock::now() + (session_stage == 0 ? 3s : 50ms);
 
-            vector<struct pollfd> pollfds;
+            std::vector<struct pollfd> pollfds;
             size_t starting_view_stack_size = lnav_data.ld_view_stack.size();
             size_t changes = 0;
             int rc;
@@ -1932,7 +1933,9 @@ looper()
 
                 if (initial_build) {
                     static bool ran_cleanup = false;
-                    vector<pair<Result<string, string>, string>> cmd_results;
+                    std::vector<std::pair<Result<std::string, std::string>,
+                                          std::string>>
+                        cmd_results;
 
                     execute_init_commands(ec, cmd_results);
 
@@ -2014,8 +2017,9 @@ looper()
                     int rc, child_stat;
 
                     rc = waitpid(*iter, &child_stat, WNOHANG);
-                    if (rc == -1 || rc == 0)
+                    if (rc == -1 || rc == 0) {
                         continue;
+                    }
 
                     iter = lnav_data.ld_children.erase(iter);
                 }
@@ -2044,7 +2048,7 @@ looper()
 void
 wait_for_children()
 {
-    vector<struct pollfd> pollfds;
+    std::vector<struct pollfd> pollfds;
     struct timeval to = {0, 333000};
 
     if (lnav_data.ld_meta_search) {
@@ -2103,7 +2107,7 @@ get_textview_for_mode(ln_mode_t mode)
 }
 
 static void
-print_errors(vector<string> error_list)
+print_errors(std::vector<std::string> error_list)
 {
     for (auto& iter : error_list) {
         fprintf(stderr,
@@ -2120,10 +2124,10 @@ main(int argc, char* argv[])
     exec_context& ec = lnav_data.ld_exec_context;
     int lpc, c, retval = EXIT_SUCCESS;
 
-    shared_ptr<piper_proc> stdin_reader;
+    std::shared_ptr<piper_proc> stdin_reader;
-    const char* stdin_out = nullptr;
+    ghc::filesystem::path stdin_out;
-    int stdin_out_fd = -1;
+    auto_fd stdin_out_fd;
-    bool exec_stdin = false, load_stdin = false;
+    bool exec_stdin = false, load_stdin = false, stdin_captured = false;
     const char* LANG = getenv("LANG");
     ghc::filesystem::path stdin_tmp_path;
 
@@ -2216,7 +2220,7 @@ main(int argc, char* argv[])
                     || strcmp("/dev/stdin", optarg) == 0) {
                     exec_stdin = true;
                 }
-                lnav_data.ld_commands.push_back("|" + string(optarg));
+                lnav_data.ld_commands.push_back("|" + std::string(optarg));
                 break;
 
             case 'I':
@@ -2359,11 +2363,11 @@ main(int argc, char* argv[])
             }
             auto file_type = file_type_result.unwrap();
 
-            string dst_name;
+            std::string dst_name;
             if (file_type == config_file_type::CONFIG) {
                 dst_name = basename(argv[lpc]);
             } else {
-                vector<intern_string_t> format_list
+                std::vector<intern_string_t> format_list
                     = load_format_file(argv[lpc], loader_errors);
 
                 if (!loader_errors.empty()) {
@@ -2616,12 +2620,14 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
     }
 
     if (!(lnav_data.ld_flags & LNF_CHECK_CONFIG)) {
-        DEFAULT_FILES.insert(make_pair(LNF_SYSLOG, string("var/log/messages")));
         DEFAULT_FILES.insert(
-            make_pair(LNF_SYSLOG, string("var/log/system.log")));
+            make_pair(LNF_SYSLOG, std::string("var/log/messages")));
-        DEFAULT_FILES.insert(make_pair(LNF_SYSLOG, string("var/log/syslog")));
         DEFAULT_FILES.insert(
-            make_pair(LNF_SYSLOG, string("var/log/syslog.log")));
+            make_pair(LNF_SYSLOG, std::string("var/log/system.log")));
+        DEFAULT_FILES.insert(
+            make_pair(LNF_SYSLOG, std::string("var/log/syslog")));
+        DEFAULT_FILES.insert(
+            make_pair(LNF_SYSLOG, std::string("var/log/syslog.log")));
     }
 
     init_lnav_commands(lnav_commands);
@@ -2669,11 +2675,11 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
 
             auto cmd_ref_path
                 = ghc::filesystem::path(internals_dir) / "cmd-ref.rst";
-            auto cmd_file = unique_ptr<FILE, decltype(&fclose)>(
+            auto cmd_file = std::unique_ptr<FILE, decltype(&fclose)>(
                 fopen(cmd_ref_path.c_str(), "w+"), fclose);
 
             if (cmd_file.get()) {
-                set<readline_context::command_t*> unique_cmds;
+                std::set<readline_context::command_t*> unique_cmds;
 
                 for (auto& cmd : lnav_commands) {
                     if (unique_cmds.find(cmd.second) != unique_cmds.end()) {
@@ -2687,9 +2693,9 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
 
             auto sql_ref_path
                 = ghc::filesystem::path(internals_dir) / "sql-ref.rst";
-            auto sql_file = unique_ptr<FILE, decltype(&fclose)>(
+            auto sql_file = std::unique_ptr<FILE, decltype(&fclose)>(
                 fopen(sql_ref_path.c_str(), "w+"), fclose);
-            set<help_text*> unique_sql_help;
+            std::set<help_text*> unique_sql_help;
 
             if (sql_file.get()) {
                 for (auto& sql : sqlite_function_help) {
@@ -2767,32 +2773,31 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
                         strerror(errno));
                 retval = EXIT_FAILURE;
             } else {
-                auto fifo_piper = make_shared<piper_proc>(
+                auto fifo_tmp_fd
-                    fifo_fd.release(),
+                    = lnav::filesystem::open_temp_file(
-                    false,
+                          ghc::filesystem::temp_directory_path()
-                    lnav::filesystem::open_temp_file(
+                          / "lnav.fifo.XXXXXX")
-                        ghc::filesystem::temp_directory_path()
+                          .map([](auto&& pair) {
-                        / "lnav.fifo.XXXXXX")
+                              ghc::filesystem::remove(pair.first);
-                        .map([](auto pair) {
-                            ghc::filesystem::remove(pair.first);
 
-                            return pair;
+                              return std::move(pair.second);
-                        })
+                          })
-                        .expect("Cannot create temporary file for FIFO")
+                          .expect("Cannot create temporary file for FIFO");
-                        .second);
+                auto fifo_piper = std::make_shared<piper_proc>(
+                    std::move(fifo_fd), false, std::move(fifo_tmp_fd));
                 auto fifo_out_fd = fifo_piper->get_fd();
                 auto desc = fmt::format(FMT_STRING("FIFO [{}]"),
                                         lnav_data.ld_fifo_counter++);
 
                 lnav_data.ld_active_files.fc_file_names[desc].with_fd(
-                    fifo_out_fd);
+                    std::move(fifo_out_fd));
                 lnav_data.ld_pipers.push_back(fifo_piper);
             }
         } else if ((abspath = realpath(argv[lpc], nullptr)) == nullptr) {
             perror("Cannot find file");
             retval = EXIT_FAILURE;
         } else if (S_ISDIR(st.st_mode)) {
-            string dir_wild(abspath.in());
+            std::string dir_wild(abspath.in());
 
             if (dir_wild[dir_wild.size() - 1] == '/') {
                 dir_wild.resize(dir_wild.size() - 1);
@@ -2837,8 +2842,8 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
                 shared_buffer_ref sbr = read_result.unwrap();
                 if (fmt->scan_for_partial(sbr, partial_len)) {
                     long line_number = distance(lf->begin(), line_iter);
-                    string full_line(sbr.get_data(), sbr.length());
+                    std::string full_line(sbr.get_data(), sbr.length());
-                    string partial_line(sbr.get_data(), partial_len);
+                    std::string partial_line(sbr.get_data(), partial_len);
 
                     fprintf(stderr,
                             "error:%s:%ld:line did not match format %s\n",
@@ -2879,7 +2884,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
     if (load_stdin && !isatty(STDIN_FILENO) && !is_dev_null(STDIN_FILENO)
         && !exec_stdin)
     {
-        if (stdin_out == nullptr) {
+        if (stdin_out.empty()) {
             auto pattern
                 = lnav::paths::dotlnav() / "stdin-captures/stdin.XXXXXX";
 
@@ -2893,20 +2898,25 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
 
             auto temp_pair = open_result.unwrap();
             stdin_tmp_path = temp_pair.first;
-            stdin_out_fd = temp_pair.second;
+            stdin_out_fd = std::move(temp_pair.second);
         } else {
-            if ((stdin_out_fd
+            auto open_res = lnav::filesystem::open_file(
-                 = open(stdin_out, O_RDWR | O_CREAT | O_TRUNC, 0600))
+                stdin_out, O_RDWR | O_CREAT | O_TRUNC, 0600);
-                == -1) {
+            if (open_res.isErr()) {
-                perror("Unable to open output file for stdin");
+                fmt::print(stderr, "error: {}\n", open_res.unwrapErr());
                 return EXIT_FAILURE;
             }
+
+            stdin_out_fd = open_res.unwrap();
         }
 
-        stdin_reader = make_shared<piper_proc>(
+        stdin_captured = true;
-            STDIN_FILENO, lnav_data.ld_flags & LNF_TIMESTAMP, stdin_out_fd);
+        stdin_reader
+            = std::make_shared<piper_proc>(auto_fd(STDIN_FILENO),
+                                           lnav_data.ld_flags & LNF_TIMESTAMP,
+                                           std::move(stdin_out_fd));
         lnav_data.ld_active_files.fc_file_names["stdin"]
-            .with_fd(auto_fd(stdin_out_fd))
+            .with_fd(stdin_reader->get_fd())
             .with_include_in_session(false);
         lnav_data.ld_pipers.push_back(stdin_reader);
     }
@@ -2967,7 +2977,9 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
             }
 
             if (lnav_data.ld_flags & LNF_HEADLESS) {
-                std::vector<pair<Result<string, string>, string>> cmd_results;
+                std::vector<
+                    std::pair<Result<std::string, std::string>, std::string>>
+                    cmd_results;
                 textview_curses *log_tc, *text_tc, *tc;
                 bool output_view = true;
 
@@ -3070,7 +3082,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
                     for (vl = tc->get_top(); vl < tc->get_inner_height();
                          ++vl, ++y) {
                         attr_line_t al;
-                        string& line = al.get_string();
+                        auto& line = al.get_string();
                         while (los != nullptr
                                && los->list_value_for_overlay(
                                    *tc, y, tc->get_inner_height(), vl, al))
@@ -3085,7 +3097,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
                             ++y;
                         }
 
-                        vector<attr_line_t> rows(1);
+                        std::vector<attr_line_t> rows(1);
                         tc->listview_value_for_rows(*tc, vl, rows);
                         if (suppress_empty_lines && rows[0].empty()) {
                             continue;
@@ -3104,7 +3116,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
                     }
                     {
                         attr_line_t al;
-                        string& line = al.get_string();
+                        auto& line = al.get_string();
 
                         while (los != nullptr
                                && los->list_value_for_overlay(
@@ -3142,7 +3154,7 @@ SELECT tbl_name FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL TABLE%'
 
         // When reading from stdin, tell the user where the capture file is
         // stored so they can look at it later.
-        if (stdin_out_fd != -1 && stdin_out == nullptr
+        if (stdin_captured && stdin_out.empty()
             && !(lnav_data.ld_flags & LNF_QUIET)
             && !(lnav_data.ld_flags & LNF_HEADLESS))
         {

src/lnav_config.cc

@@ -46,8 +46,8 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-#include "auto_fd.hh"
 #include "auto_mem.hh"
+#include "base/auto_fd.hh"
 #include "base/auto_pid.hh"
 #include "base/fs_util.hh"
 #include "base/injector.bind.hh"
@@ -62,7 +62,7 @@
 #include "yajlpp/yajlpp.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
+using namespace std::chrono_literals;
 
 static const int MAX_CRASH_LOG_COUNT = 16;
 static const auto STDIN_CAPTURE_RETENTION = 24h;
@@ -159,7 +159,8 @@ ensure_dotlnav()
                     continue;
                 }
 
-                if (chrono::system_clock::from_time_t(st.st_mtime) > old_time) {
+                if (std::chrono::system_clock::from_time_t(st.st_mtime)
+                    > old_time) {
                     continue;
                 }
 
@@ -178,7 +179,7 @@ install_from_git(const char* repo)
     auto formats_path = lnav::paths::dotlnav() / "formats";
     auto configs_path = lnav::paths::dotlnav() / "configs";
     auto staging_path = lnav::paths::dotlnav() / "staging";
-    string local_name = std::regex_replace(repo, repo_name_converter, "_");
+    auto local_name = std::regex_replace(repo, repo_name_converter, "_");
 
     auto local_formats_path = formats_path / local_name;
     auto local_configs_path = configs_path / local_name;
@@ -307,7 +308,7 @@ update_installs_from_git()
 static int
 read_repo_path(yajlpp_parse_context* ypc, const unsigned char* str, size_t len)
 {
-    string path = string((const char*) str, len);
+    auto path = std::string((const char*) str, len);
 
     install_from_git(path.c_str());
 
@@ -367,9 +368,9 @@ install_extra_formats()
 }
 
 struct userdata {
-    userdata(vector<string>& errors) : ud_errors(errors){};
+    userdata(std::vector<std::string>& errors) : ud_errors(errors){};
 
-    vector<string>& ud_errors;
+    std::vector<std::string>& ud_errors;
 };
 
 static void
@@ -418,30 +419,30 @@ static const struct json_path_container keymap_def_handlers
                    return &retval;
                })
            .with_path_provider<key_map>(
-               [](key_map* km, vector<string>& paths_out) {
+               [](key_map* km, std::vector<std::string>& paths_out) {
                    for (const auto& iter : km->km_seq_to_cmd) {
                        paths_out.emplace_back(iter.first);
                    }
                })
            .with_children(key_command_handlers)};
 
-static const struct json_path_container keymap_defs_handlers
+static const struct json_path_container keymap_defs_handlers = {
-    = {yajlpp::pattern_property_handler("(?<keymap_name>[\\w\\-]+)")
+    yajlpp::pattern_property_handler("(?<keymap_name>[\\w\\-]+)")
-           .with_description("The keymap definitions")
+        .with_description("The keymap definitions")
-           .with_obj_provider<key_map, _lnav_config>(
+        .with_obj_provider<key_map, _lnav_config>(
-               [](const yajlpp_provider_context& ypc, _lnav_config* root) {
+            [](const yajlpp_provider_context& ypc, _lnav_config* root) {
-                   key_map& retval
+                key_map& retval
-                       = root->lc_ui_keymaps[ypc.ypc_extractor.get_substr(
+                    = root->lc_ui_keymaps[ypc.ypc_extractor.get_substr(
-                           "keymap_name")];
+                        "keymap_name")];
-                   return &retval;
+                return &retval;
-               })
+            })
-           .with_path_provider<_lnav_config>(
+        .with_path_provider<_lnav_config>(
-               [](struct _lnav_config* cfg, vector<string>& paths_out) {
+            [](struct _lnav_config* cfg, std::vector<std::string>& paths_out) {
-                   for (const auto& iter : cfg->lc_ui_keymaps) {
+                for (const auto& iter : cfg->lc_ui_keymaps) {
-                       paths_out.emplace_back(iter.first);
+                    paths_out.emplace_back(iter.first);
-                   }
+                }
-               })
+            })
-           .with_children(keymap_def_handlers)};
+        .with_children(keymap_def_handlers)};
 
 static const struct json_path_container global_var_handlers = {
     yajlpp::pattern_property_handler("(?<var_name>\\w+)")
@@ -450,7 +451,7 @@ static const struct json_path_container global_var_handlers = {
             "A global variable definition.  Global variables can be referenced "
             "in scripts, SQL statements, or commands.")
         .with_path_provider<_lnav_config>(
-            [](struct _lnav_config* cfg, vector<string>& paths_out) {
+            [](struct _lnav_config* cfg, std::vector<std::string>& paths_out) {
                 for (const auto& iter : cfg->lc_global_vars) {
                     paths_out.emplace_back(iter.first);
                 }
@@ -783,7 +784,7 @@ static const struct json_path_container theme_log_level_styles_handlers
                    return &sc;
                })
            .with_path_provider<lnav_theme>(
-               [](struct lnav_theme* cfg, vector<string>& paths_out) {
+               [](struct lnav_theme* cfg, std::vector<std::string>& paths_out) {
                    for (int lpc = LEVEL_TRACE; lpc < LEVEL__MAX; lpc++) {
                        paths_out.emplace_back(level_names[lpc]);
                    }
@@ -818,7 +819,7 @@ static const struct json_path_container theme_highlights_handlers
                    return &hc;
                })
            .with_path_provider<lnav_theme>(
-               [](struct lnav_theme* cfg, vector<string>& paths_out) {
+               [](struct lnav_theme* cfg, std::vector<std::string>& paths_out) {
                    for (const auto& pair : cfg->lt_highlights) {
                        paths_out.emplace_back(pair.first);
                    }
@@ -830,7 +831,7 @@ static const struct json_path_container theme_vars_handlers
            .with_synopsis("name")
            .with_description("A theme variable definition")
            .with_path_provider<lnav_theme>(
-               [](struct lnav_theme* lt, vector<string>& paths_out) {
+               [](struct lnav_theme* lt, std::vector<std::string>& paths_out) {
                    for (const auto& iter : lt->lt_vars) {
                        paths_out.emplace_back(iter.first);
                    }
@@ -863,24 +864,24 @@ static const struct json_path_container theme_def_handlers = {
         .with_children(theme_highlights_handlers),
 };
 
-static const struct json_path_container theme_defs_handlers
+static const struct json_path_container theme_defs_handlers = {
-    = {yajlpp::pattern_property_handler("(?<theme_name>[\\w\\-]+)")
+    yajlpp::pattern_property_handler("(?<theme_name>[\\w\\-]+)")
-           .with_description("Theme definitions")
+        .with_description("Theme definitions")
-           .with_obj_provider<lnav_theme, _lnav_config>(
+        .with_obj_provider<lnav_theme, _lnav_config>(
-               [](const yajlpp_provider_context& ypc, _lnav_config* root) {
+            [](const yajlpp_provider_context& ypc, _lnav_config* root) {
-                   lnav_theme& lt
+                lnav_theme& lt
-                       = root->lc_ui_theme_defs[ypc.ypc_extractor.get_substr(
+                    = root->lc_ui_theme_defs[ypc.ypc_extractor.get_substr(
-                           "theme_name")];
+                        "theme_name")];
 
-                   return &lt;
+                return &lt;
-               })
+            })
-           .with_path_provider<_lnav_config>(
+        .with_path_provider<_lnav_config>(
-               [](struct _lnav_config* cfg, vector<string>& paths_out) {
+            [](struct _lnav_config* cfg, std::vector<std::string>& paths_out) {
-                   for (const auto& iter : cfg->lc_ui_theme_defs) {
+                for (const auto& iter : cfg->lc_ui_theme_defs) {
-                       paths_out.emplace_back(iter.first);
+                    paths_out.emplace_back(iter.first);
-                   }
+                }
-               })
+            })
-           .with_children(theme_def_handlers)};
+        .with_children(theme_def_handlers)};
 
 static const struct json_path_container ui_handlers = {
     yajlpp::property_handler("clock-format")
@@ -1072,7 +1073,7 @@ static const struct json_path_container sysclip_impls_handlers = {
                 return &retval;
             })
         .with_path_provider<_lnav_config>(
-            [](struct _lnav_config* cfg, vector<string>& paths_out) {
+            [](struct _lnav_config* cfg, std::vector<std::string>& paths_out) {
                 for (const auto& iter : cfg->lc_sysclip.c_clipboard_impls) {
                     paths_out.emplace_back(iter.first);
                 }
@@ -1104,21 +1105,21 @@ static const struct json_path_container tuning_handlers = {
         .with_children(sysclip_handlers),
 };
 
-static const set<string> SUPPORTED_CONFIG_SCHEMAS = {
+static const std::set<std::string> SUPPORTED_CONFIG_SCHEMAS = {
     "https://lnav.org/schemas/config-v1.schema.json",
 };
 
 const char* DEFAULT_FORMAT_SCHEMA
     = "https://lnav.org/schemas/format-v1.schema.json";
 
-const set<string> SUPPORTED_FORMAT_SCHEMAS = {
+const std::set<std::string> SUPPORTED_FORMAT_SCHEMAS = {
     DEFAULT_FORMAT_SCHEMA,
 };
 
 static int
 read_id(yajlpp_parse_context* ypc, const unsigned char* str, size_t len)
 {
-    auto file_id = string((const char*) str, len);
+    auto file_id = std::string((const char*) str, len);
 
     if (SUPPORTED_CONFIG_SCHEMAS.count(file_id) == 0) {
         ypc->report_error(
@@ -1176,7 +1177,7 @@ detect_config_file_type(const ghc::filesystem::path& path)
     auto read_res = lnav::filesystem::read_file(path);
 
     if (read_res.isErr()) {
-        return Err(fmt::format(FMT_STRING("unable to open file: {} -- {}"),
+        return Err(fmt::format(FMT_STRING("unable to open file4: {} -- {}"),
                                path.string(),
                                read_res.unwrapErr()));
     }
@@ -1187,7 +1188,7 @@ detect_config_file_type(const ghc::filesystem::path& path)
     }
 
     char error_buffer[1024];
-    auto content_tree = unique_ptr<yajl_val_s, decltype(&yajl_tree_free)>(
+    auto content_tree = std::unique_ptr<yajl_val_s, decltype(&yajl_tree_free)>(
         yajl_tree_parse(content.c_str(), error_buffer, sizeof(error_buffer)),
         yajl_tree_free);
     if (content_tree == nullptr) {
@@ -1216,7 +1217,7 @@ detect_config_file_type(const ghc::filesystem::path& path)
 static void
 load_config_from(_lnav_config& lconfig,
                  const ghc::filesystem::path& path,
-                 vector<string>& errors)
+                 std::vector<std::string>& errors)
 {
     yajlpp_parse_context ypc(path.string(), &lnav_config_handlers);
     struct userdata ud(errors);
@@ -1269,7 +1270,7 @@ static void
 load_default_config(struct _lnav_config& config_obj,
                     const std::string& path,
                     const bin_src_file& bsf,
-                    vector<string>& errors)
+                    std::vector<std::string>& errors)
 {
     yajlpp_parse_context ypc_builtin(bsf.get_name(), &lnav_config_handlers);
     auto_mem<yajl_handle_t> handle(yajl_free);
@@ -1297,7 +1298,7 @@ load_default_config(struct _lnav_config& config_obj,
 static void
 load_default_configs(struct _lnav_config& config_obj,
                      const std::string& path,
-                     vector<string>& errors)
+                     std::vector<std::string>& errors)
 {
     for (auto& bsf : lnav_config_json) {
         load_default_config(config_obj, path, bsf, errors);
@@ -1305,8 +1306,8 @@ load_default_configs(struct _lnav_config& config_obj,
 }
 
 void
-load_config(const vector<ghc::filesystem::path>& extra_paths,
+load_config(const std::vector<ghc::filesystem::path>& extra_paths,
-            vector<string>& errors)
+            std::vector<std::string>& errors)
 {
     auto user_config = lnav::paths::dotlnav() / "config.json";
 
@@ -1369,7 +1370,7 @@ load_config(const vector<ghc::filesystem::path>& extra_paths,
 void
 reset_config(const std::string& path)
 {
-    vector<string> errors;
+    std::vector<std::string> errors;
 
     load_default_configs(lnav_config, path, errors);
 
@@ -1380,7 +1381,7 @@ reset_config(const std::string& path)
     }
 }
 
-string
+std::string
 save_config()
 {
     yajlpp_gen gen;
@@ -1390,7 +1391,7 @@ save_config()
 
     yajl_gen_config(gen, yajl_gen_beautify, true);
     yajlpp_gen_context ygc(gen, lnav_config_handlers);
-    vector<string> errors;
+    std::vector<std::string> errors;
 
     ygc.with_default_obj(lnav_default_config).with_obj(lnav_config);
     ygc.gen();
@@ -1403,7 +1404,7 @@ save_config()
             == -1)
         {
             return "error: unable to save configuration -- "
-                + string(strerror(errno));
+                + std::string(strerror(errno));
         }
 
         string_fragment bits = gen.to_string_fragment();
@@ -1417,7 +1418,7 @@ save_config()
 }
 
 void
-reload_config(vector<string>& errors)
+reload_config(std::vector<std::string>& errors)
 {
     lnav_config_listener* curr = lnav_config_listener::LISTENER_LIST;
 
@@ -1426,7 +1427,7 @@ reload_config(vector<string>& errors)
                                   const std::string& errmsg) {
             auto cb = [&cfg_value, &errors, &errmsg](
                           const json_path_handler_base& jph,
-                          const string& path,
+                          const std::string& path,
                           void* mem) {
                 if (mem != cfg_value) {
                     return;

src/log_actions.cc

@@ -33,18 +33,16 @@
 #include "config.h"
 #include "piper_proc.hh"
 
-using namespace std;
+std::string
-
+action_delegate::execute_action(const std::string& action_name)
-string
-action_delegate::execute_action(const string& action_name)
 {
     auto& ldh = this->ad_log_helper;
     auto value_index = this->ad_press_value;
     logline_value& lv = ldh.ldh_line_values[value_index];
-    shared_ptr<logfile> lf = ldh.ldh_file;
+    auto lf = ldh.ldh_file;
     const auto format = lf->get_format();
     pid_t child_pid;
-    string retval;
+    std::string retval;
 
     auto iter = format->lf_action_defs.find(action_name);
 
@@ -65,15 +63,16 @@ action_delegate::execute_action(const string& action_name)
 
     switch (child_pid) {
         case -1:
-            retval = "error: unable to fork child process -- "
+            retval = fmt::format(
-                + string(strerror(errno));
+                FMT_STRING("error: unable to fork child process -- {}"),
+                strerror(errno));
             break;
         case 0: {
             const char* args[action.ad_cmdline.size() + 1];
-            set<std::string> path_set(format->get_source_path());
+            std::set<std::string> path_set(format->get_source_path());
             char env_buffer[64];
             int value_line;
-            string path;
+            std::string path;
 
             dup2(STDOUT_FILENO, STDERR_FILENO);
             setenv("LNAV_ACTION_FILE", lf->get_filename().c_str(), 1);
@@ -96,7 +95,7 @@ action_delegate::execute_action(const string& action_name)
                 }
                 path += path_iter;
             }
-            path += ":" + string(getenv("PATH"));
+            path += ":" + std::string(getenv("PATH"));
             setenv("PATH", path.c_str(), 1);
             for (size_t lpc = 0; lpc < action.ad_cmdline.size(); lpc++) {
                 args[lpc] = action.ad_cmdline[lpc].c_str();
@@ -112,7 +111,7 @@ action_delegate::execute_action(const string& action_name)
         default: {
             static int exec_count = 0;
 
-            string value = lv.to_string();
+            const auto value = lv.to_string();
 
             this->ad_child_cb(child_pid);
 
@@ -122,8 +121,8 @@ action_delegate::execute_action(const string& action_name)
             in_pipe.close();
 
             if (out_pipe.read_end() != -1) {
-                auto pp = make_shared<piper_proc>(
+                auto pp = std::make_shared<piper_proc>(
-                    out_pipe.read_end(),
+                    std::move(out_pipe.read_end()),
                     false,
                     lnav::filesystem::open_temp_file(
                         ghc::filesystem::temp_directory_path()
@@ -209,8 +208,8 @@ action_delegate::text_handle_mouse(textview_curses& tc, mouse_event& me)
                 int x_offset = this->ad_line_index + mouse_left;
 
                 if (lv.lv_origin.contains(x_offset)) {
-                    shared_ptr<logfile> lf = this->ad_log_helper.ldh_file;
+                    auto lf = this->ad_log_helper.ldh_file;
-                    const vector<string>* actions;
+                    const std::vector<std::string>* actions;
 
                     actions = lf->get_format()->get_actions(lv);
                     if (actions != nullptr && !actions->empty()) {

src/log_format.cc

@@ -46,8 +46,6 @@
 #include "yajlpp/yajlpp.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
-
 static auto intern_lifetime = intern_string::get_table_lifetime();
 string_attr_type logline::L_PREFIX("prefix");
 string_attr_type logline::L_TIMESTAMP("timestamp");
@@ -232,9 +230,9 @@ logline_value::to_string() const
     return {buffer};
 }
 
-vector<std::shared_ptr<log_format>> log_format::lf_root_formats;
+std::vector<std::shared_ptr<log_format>> log_format::lf_root_formats;
 
-vector<std::shared_ptr<log_format>>&
+std::vector<std::shared_ptr<log_format>>&
 log_format::get_root_formats()
 {
     return lf_root_formats;
@@ -471,7 +469,7 @@ read_json_int(yajlpp_parse_context* ypc, long long val)
             jlu->jlu_base_line->set_level(
                 jlu->jlu_format->convert_level(pi, &level_cap));
         } else {
-            vector<pair<int64_t, log_level_t>>::iterator iter;
+            std::vector<std::pair<int64_t, log_level_t>>::iterator iter;
 
             for (iter = jlu->jlu_format->elf_level_pairs.begin();
                  iter != jlu->jlu_format->elf_level_pairs.end();
@@ -735,7 +733,8 @@ external_log_format::scan(logfile& lf,
                 log_debug("Unable to parse line at offset %d: %s",
                           li.li_file_range.fr_offset,
                           msg);
-                line_count = count(msg, msg + strlen((char*) msg), '\n') + 1;
+                line_count
+                    = std::count(msg, msg + strlen((char*) msg), '\n') + 1;
                 yajl_free_error(handle, msg);
             }
             if (!this->lf_specialized) {
@@ -836,7 +835,7 @@ external_log_format::scan(logfile& lf,
             }
 
             if (mod_index && level_cap && body_cap) {
-                auto mod_elf = dynamic_pointer_cast<external_log_format>(
+                auto mod_elf = std::dynamic_pointer_cast<external_log_format>(
                     mod_iter->second.mf_mod_format);
 
                 if (mod_elf) {
@@ -1124,9 +1123,9 @@ void
 external_log_format::rewrite(exec_context& ec,
                              shared_buffer_ref& line,
                              string_attrs_t& sa,
-                             string& value_out)
+                             std::string& value_out)
 {
-    vector<logline_value>::iterator shift_iter;
+    std::vector<logline_value>::iterator shift_iter;
     auto& values = *ec.ec_line_values;
 
     value_out.assign(line.get_data(), line.length());
@@ -1333,7 +1332,7 @@ external_log_format::get_subline(const logline& ll,
             || yajl_complete_parse(handle) != yajl_status_ok)
         {
             unsigned char* msg;
-            string full_msg;
+            std::string full_msg;
 
             msg = yajl_get_error(
                 handle, 1, (const unsigned char*) sbr.get_data(), sbr.length());
@@ -1387,7 +1386,7 @@ external_log_format::get_subline(const logline& ll,
                                           this->jlf_line_values.end(),
                                           logline_value_cmp(&jfe.jfe_value));
                         if (lv_iter != this->jlf_line_values.end()) {
-                            string str = lv_iter->to_string();
+                            auto str = lv_iter->to_string();
                             size_t nl_pos = str.find('\n');
 
                             lr.lr_start = this->jlf_cached_line.size();
@@ -1436,7 +1435,7 @@ external_log_format::get_subline(const logline& ll,
                                 this->json_append(jfe, str.c_str(), str.size());
                             }
 
-                            if (nl_pos == string::npos || full_message) {
+                            if (nl_pos == std::string::npos || full_message) {
                                 lr.lr_end = this->jlf_cached_line.size();
                             } else {
                                 lr.lr_end = lr.lr_start + nl_pos;
@@ -1628,7 +1627,7 @@ external_log_format::build(std::vector<std::string>& errors)
     if (!this->lf_timestamp_field.empty()) {
         auto& vd = this->elf_value_defs[this->lf_timestamp_field];
         if (vd.get() == nullptr) {
-            vd = make_shared<external_log_format::value_def>(
+            vd = std::make_shared<external_log_format::value_def>(
                 this->lf_timestamp_field, value_kind_t::VALUE_TEXT, -1, this);
         }
         vd->vd_meta.lvm_name = this->lf_timestamp_field;
@@ -1641,7 +1640,7 @@ external_log_format::build(std::vector<std::string>& errors)
     {
         auto& vd = this->elf_value_defs[this->elf_level_field];
         if (vd.get() == nullptr) {
-            vd = make_shared<external_log_format::value_def>(
+            vd = std::make_shared<external_log_format::value_def>(
                 this->elf_level_field, value_kind_t::VALUE_TEXT, -1, this);
         }
         vd->vd_meta.lvm_name = this->elf_level_field;
@@ -1651,7 +1650,7 @@ external_log_format::build(std::vector<std::string>& errors)
     if (!this->elf_body_field.empty()) {
         auto& vd = this->elf_value_defs[this->elf_body_field];
         if (vd.get() == nullptr) {
-            vd = make_shared<external_log_format::value_def>(
+            vd = std::make_shared<external_log_format::value_def>(
                 this->elf_body_field, value_kind_t::VALUE_TEXT, -1, this);
         }
         vd->vd_meta.lvm_name = this->elf_body_field;
@@ -1687,8 +1686,8 @@ external_log_format::build(std::vector<std::string>& errors)
             errors.push_back("error:" + this->elf_name.to_string() + ".regex["
                              + iter->first + "]" + ":" + pat.p_string);
             errors.push_back("error:" + this->elf_name.to_string() + ".regex["
-                             + iter->first + "]" + ":" + string(e.e_offset, ' ')
+                             + iter->first + "]" + ":"
-                             + "^");
+                             + std::string(e.e_offset, ' ') + "^");
             continue;
         }
         for (pcre_named_capture::iterator name_iter = pat.p_pcre->named_begin();
@@ -1903,8 +1902,8 @@ external_log_format::build(std::vector<std::string>& errors)
                             PTIMEC_FORMATS[lpc].pf_func(&tm, ts, off, ts_len);
                             errors.push_back(
                                 "  format: "
-                                + string(PTIMEC_FORMATS[lpc].pf_fmt)
+                                + std::string(PTIMEC_FORMATS[lpc].pf_fmt)
-                                + "; matched: " + string(ts, off));
+                                + "; matched: " + std::string(ts, off));
                         }
                     } else {
                         for (int lpc = 0; custom_formats[lpc] != nullptr; lpc++)
@@ -1913,9 +1912,9 @@ external_log_format::build(std::vector<std::string>& errors)
 
                             ptime_fmt(
                                 custom_formats[lpc], &tm, ts, off, ts_len);
-                            errors.push_back("  format: "
+                            errors.push_back(
-                                             + string(custom_formats[lpc])
+                                "  format: " + std::string(custom_formats[lpc])
-                                             + "; matched: " + string(ts, off));
+                                + "; matched: " + std::string(ts, off));
                         }
                     }
                 }
@@ -2094,13 +2093,13 @@ external_log_format::build(std::vector<std::string>& errors)
         if (code == nullptr) {
             errors.push_back("error:" + this->elf_name.to_string()
                              + ":highlighters/" + hd_pair.first.to_string()
-                             + ":" + string(errptr));
+                             + ":" + std::string(errptr));
             errors.push_back("error:" + this->elf_name.to_string()
                              + ":highlighters/" + hd_pair.first.to_string()
                              + ":" + pattern);
             errors.push_back("error:" + this->elf_name.to_string()
                              + ":highlighters/" + hd_pair.first.to_string()
-                             + ":" + string(eoff, ' ') + "^");
+                             + ":" + std::string(eoff, ' ') + "^");
         } else {
             this->lf_highlighters.emplace_back(code);
             this->lf_highlighters.back()
@@ -2116,8 +2115,7 @@ void
 external_log_format::register_vtabs(log_vtab_manager* vtab_manager,
                                     std::vector<std::string>& errors)
 {
-    vector<pair<intern_string_t, string>>::iterator search_iter;
+    for (auto search_iter = this->elf_search_tables.begin();
-    for (search_iter = this->elf_search_tables.begin();
          search_iter != this->elf_search_tables.end();
          ++search_iter)
     {
@@ -2136,9 +2134,7 @@ external_log_format::register_vtabs(log_vtab_manager* vtab_manager,
 
         auto lst = std::make_shared<log_search_table>(re_res.unwrap(),
                                                       search_iter->first);
-        string errmsg;
+        auto errmsg = vtab_manager->register_vtab(lst);
-
-        errmsg = vtab_manager->register_vtab(lst);
         if (!errmsg.empty()) {
             errors.push_back("error:" + this->elf_name.to_string() + ":"
                              + search_iter->first.to_string()
@@ -2148,7 +2144,7 @@ external_log_format::register_vtabs(log_vtab_manager* vtab_manager,
 }
 
 bool
-external_log_format::match_samples(const vector<sample>& samples) const
+external_log_format::match_samples(const std::vector<sample>& samples) const
 {
     for (const auto& sample_iter : samples) {
         for (const auto& pat_iter : this->elf_pattern_order) {
@@ -2175,7 +2171,7 @@ public:
     external_log_table(const external_log_format& elf)
         : log_format_vtab_impl(elf), elt_format(elf){};
 
-    void get_columns(vector<vtab_column>& cols) const
+    void get_columns(std::vector<vtab_column>& cols) const
     {
         const external_log_format& elf = this->elt_format;
 
@@ -2275,7 +2271,7 @@ public:
         return false;
     };
 
-    virtual void extract(shared_ptr<logfile> lf,
+    virtual void extract(std::shared_ptr<logfile> lf,
                          uint64_t line_number,
                          shared_buffer_ref& line,
                          std::vector<logline_value>& values)
@@ -2339,7 +2335,7 @@ external_log_format::specialized(int fmt_lock)
 }
 
 bool
-external_log_format::match_name(const string& filename)
+external_log_format::match_name(const std::string& filename)
 {
     if (this->elf_file_pattern.empty()) {
         return true;

src/log_format_impls.cc

@@ -45,8 +45,6 @@
 #include "sql_util.hh"
 #include "yajlpp/yajlpp.hh"
 
-using namespace std;
-
 static const pcrepp RDNS_PATTERN(
     "^(?:com|net|org|edu|[a-z][a-z])"
     "(\\.\\w+)+(.+)");
@@ -60,12 +58,12 @@ static const pcrepp RDNS_PATTERN(
  * @return     The scrubbed version of the input string or the original string
  *   if it is not a reverse-DNS string.
  */
-static string
+static std::string
-scrub_rdns(const string& str)
+scrub_rdns(const std::string& str)
 {
     pcre_context_static<30> context;
     pcre_input input(str);
-    string retval;
+    std::string retval;
 
     if (RDNS_PATTERN.match(context, input)) {
         pcre_context::capture_t* cap;
@@ -142,11 +140,11 @@ class generic_log_format : public log_format {
         return intern_string::lookup("generic_log");
     };
 
-    void scrub(string& line) override
+    void scrub(std::string& line) override
     {
         pcre_context_static<30> context;
         pcre_input pi(line);
-        string new_line;
+        std::string new_line;
 
         if (scrub_pattern().match(context, pi)) {
             pcre_context::capture_t* cap;
@@ -160,7 +158,7 @@ class generic_log_format : public log_format {
     };
 
     scan_result_t scan(logfile& lf,
-                       vector<logline>& dst,
+                       std::vector<logline>& dst,
                        const line_info& li,
                        shared_buffer_ref& sbr) override
     {
@@ -236,16 +234,16 @@ class generic_log_format : public log_format {
         sa.emplace_back(lr, &SA_BODY);
     };
 
-    shared_ptr<log_format> specialized(int fmt_lock) override
+    std::shared_ptr<log_format> specialized(int fmt_lock) override
     {
         return std::make_shared<generic_log_format>(*this);
     };
 };
 
-string
+std::string
 from_escaped_string(const char* str, size_t len)
 {
-    string retval;
+    std::string retval;
 
     for (size_t lpc = 0; lpc < len; lpc++) {
         switch (str[lpc]) {
@@ -549,7 +547,7 @@ public:
 
         this->clear();
 
-        string sep
+        auto sep
             = from_escaped_string(pi.get_substr_start(pc[0]), pc[0]->length());
         this->blf_separator = intern_string::lookup(sep);
 
@@ -624,14 +622,14 @@ public:
                     if (field_type == "time") {
                         fd.with_kind(value_kind_t::VALUE_TIMESTAMP);
                     } else if (field_type == "string") {
-                        bool ident = binary_search(begin(KNOWN_IDS),
+                        bool ident = std::binary_search(std::begin(KNOWN_IDS),
-                                                   end(KNOWN_IDS),
+                                                        std::end(KNOWN_IDS),
-                                                   fd.fd_meta.lvm_name);
+                                                        fd.fd_meta.lvm_name);
                         fd.with_kind(value_kind_t::VALUE_TEXT, ident);
                     } else if (field_type == "count") {
-                        bool ident = binary_search(begin(KNOWN_IDS),
+                        bool ident = std::binary_search(std::begin(KNOWN_IDS),
-                                                   end(KNOWN_IDS),
+                                                        std::end(KNOWN_IDS),
-                                                   fd.fd_meta.lvm_name);
+                                                        fd.fd_meta.lvm_name);
                         fd.with_kind(value_kind_t::VALUE_INTEGER, ident)
                             .with_numeric_index(numeric_count);
                         numeric_count += 1;
@@ -731,7 +729,7 @@ public:
 
     std::shared_ptr<log_format> specialized(int fmt_lock = -1) override
     {
-        return make_shared<bro_log_format>(*this);
+        return std::make_shared<bro_log_format>(*this);
     };
 
     class bro_log_table : public log_format_vtab_impl {
@@ -741,7 +739,7 @@ public:
         {
         }
 
-        void get_columns(vector<vtab_column>& cols) const override
+        void get_columns(std::vector<vtab_column>& cols) const override
         {
             for (const auto& fd : this->blt_format.blf_field_defs) {
                 std::pair<int, unsigned int> type_pair
@@ -772,9 +770,10 @@ public:
         const bro_log_format& blt_format;
     };
 
-    static map<intern_string_t, std::shared_ptr<bro_log_table>>& get_tables()
+    static std::map<intern_string_t, std::shared_ptr<bro_log_table>>&
+    get_tables()
     {
-        static map<intern_string_t, std::shared_ptr<bro_log_table>> retval;
+        static std::map<intern_string_t, std::shared_ptr<bro_log_table>> retval;
 
         return retval;
     };
@@ -808,7 +807,7 @@ public:
     intern_string_t blf_set_separator;
     intern_string_t blf_empty_field;
     intern_string_t blf_unset_field;
-    vector<field_def> blf_field_defs;
+    std::vector<field_def> blf_field_defs;
 };
 
 struct ws_separated_string {
@@ -1321,7 +1320,7 @@ public:
 
     std::shared_ptr<log_format> specialized(int fmt_lock = -1) override
     {
-        return make_shared<w3c_log_format>(*this);
+        return std::make_shared<w3c_log_format>(*this);
     };
 
     class w3c_log_table : public log_format_vtab_impl {
@@ -1331,7 +1330,7 @@ public:
         {
         }
 
-        void get_columns(vector<vtab_column>& cols) const override
+        void get_columns(std::vector<vtab_column>& cols) const override
         {
             for (const auto& fd : KNOWN_FIELDS) {
                 auto type_pair = log_vtab_impl::logline_value_to_sqlite_type(
@@ -1368,9 +1367,10 @@ public:
         const w3c_log_format& wlt_format;
     };
 
-    static map<intern_string_t, std::shared_ptr<w3c_log_table>>& get_tables()
+    static std::map<intern_string_t, std::shared_ptr<w3c_log_table>>&
+    get_tables()
     {
-        static map<intern_string_t, std::shared_ptr<w3c_log_table>> retval;
+        static std::map<intern_string_t, std::shared_ptr<w3c_log_table>> retval;
 
         return retval;
     };
@@ -1401,7 +1401,7 @@ public:
 
     date_time_scanner wlf_time_scanner;
     intern_string_t wlf_format_name;
-    vector<field_def> wlf_field_defs;
+    std::vector<field_def> wlf_field_defs;
 };
 
 static int KNOWN_FIELD_INDEX = 0;
@@ -1566,7 +1566,7 @@ public:
         {
         }
 
-        void get_columns(vector<vtab_column>& cols) const override
+        void get_columns(std::vector<vtab_column>& cols) const override
         {
             static const auto FIELDS = std::string("fields");
 
@@ -1574,7 +1574,7 @@ public:
         };
     };
 
-    shared_ptr<log_vtab_impl> get_vtab_impl() const override
+    std::shared_ptr<log_vtab_impl> get_vtab_impl() const override
     {
         static auto retval = std::make_shared<logfmt_log_table>(*this);
 
@@ -1582,7 +1582,7 @@ public:
     }
 
     scan_result_t scan(logfile& lf,
-                       vector<logline>& dst,
+                       std::vector<logline>& dst,
                        const line_info& li,
                        shared_buffer_ref& sbr) override
     {
@@ -1667,7 +1667,7 @@ public:
     void annotate(uint64_t line_number,
                   shared_buffer_ref& sbr,
                   string_attrs_t& sa,
-                  vector<logline_value>& values,
+                  std::vector<logline_value>& values,
                   bool annotate_module) const override
     {
         static const auto FIELDS_NAME = intern_string::lookup("fields");
@@ -1767,7 +1767,7 @@ public:
         }
     }
 
-    shared_ptr<log_format> specialized(int fmt_lock) override
+    std::shared_ptr<log_format> specialized(int fmt_lock) override
     {
         return std::make_shared<logfmt_format>(*this);
     };

src/log_format_loader.cc

@@ -40,7 +40,7 @@
 #include <libgen.h>
 #include <sys/stat.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/fs_util.hh"
 #include "base/paths.hh"
 #include "base/string_util.hh"
@@ -52,19 +52,16 @@
 #include "file_format.hh"
 #include "fmt/format.h"
 #include "lnav_config.hh"
-#include "lnav_util.hh"
 #include "log_format_ext.hh"
 #include "sql_util.hh"
 #include "yajlpp/yajlpp.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
-
 static void extract_metadata(const char* contents,
                              size_t len,
                              struct script_metadata& meta_out);
 
-typedef map<intern_string_t, std::shared_ptr<external_log_format>>
+typedef std::map<intern_string_t, std::shared_ptr<external_log_format>>
     log_formats_map_t;
 
 static auto intern_lifetime = intern_string::get_table_lifetime();
@@ -72,7 +69,7 @@ static log_formats_map_t LOG_FORMATS;
 
 struct userdata {
     ghc::filesystem::path ud_format_path;
-    vector<intern_string_t>* ud_format_names{nullptr};
+    std::vector<intern_string_t>* ud_format_names{nullptr};
     std::vector<std::string>* ud_errors{nullptr};
 };
 
@@ -80,7 +77,7 @@ static external_log_format*
 ensure_format(const yajlpp_provider_context& ypc, userdata* ud)
 {
     const intern_string_t name = ypc.get_substr_i(0);
-    vector<intern_string_t>* formats = ud->ud_format_names;
+    std::vector<intern_string_t>* formats = ud->ud_format_names;
     external_log_format* retval;
 
     retval = LOG_FORMATS[name].get();
@@ -105,11 +102,11 @@ ensure_format(const yajlpp_provider_context& ypc, userdata* ud)
 static external_log_format::pattern*
 pattern_provider(const yajlpp_provider_context& ypc, external_log_format* elf)
 {
-    string regex_name = ypc.get_substr(0);
+    auto regex_name = ypc.get_substr(0);
     auto& pat = elf->elf_patterns[regex_name];
 
     if (pat.get() == nullptr) {
-        pat = make_shared<external_log_format::pattern>();
+        pat = std::make_shared<external_log_format::pattern>();
     }
 
     if (pat->p_config_path.empty()) {
@@ -126,10 +123,10 @@ value_def_provider(const yajlpp_provider_context& ypc, external_log_format* elf)
     const intern_string_t value_name = ypc.get_substr_i(0);
 
     auto iter = elf->elf_value_defs.find(value_name);
-    shared_ptr<external_log_format::value_def> retval;
+    std::shared_ptr<external_log_format::value_def> retval;
 
     if (iter == elf->elf_value_defs.end()) {
-        retval = make_shared<external_log_format::value_def>(
+        retval = std::make_shared<external_log_format::value_def>(
             value_name, value_kind_t::VALUE_TEXT, -1, elf);
         elf->elf_value_defs[value_name] = retval;
         elf->elf_value_def_order.emplace_back(retval);
@@ -173,7 +170,7 @@ static int
 read_format_bool(yajlpp_parse_context* ypc, int val)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string field_name = ypc->get_path_fragment(1);
+    auto field_name = ypc->get_path_fragment(1);
 
     if (field_name == "convert-to-local-time")
         elf->lf_date_time.dts_local_time = val;
@@ -193,7 +190,7 @@ static int
 read_format_double(yajlpp_parse_context* ypc, double val)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string field_name = ypc->get_path_fragment(1);
+    auto field_name = ypc->get_path_fragment(1);
 
     if (field_name == "timestamp-divisor") {
         if (val <= 0) {
@@ -213,7 +210,7 @@ static int
 read_format_int(yajlpp_parse_context* ypc, long long val)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string field_name = ypc->get_path_fragment(1);
+    auto field_name = ypc->get_path_fragment(1);
 
     if (field_name == "timestamp-divisor") {
         if (val <= 0) {
@@ -236,8 +233,8 @@ read_format_field(yajlpp_parse_context* ypc,
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
     auto leading_slash = len > 0 && str[0] == '/';
-    auto value = string((const char*) (leading_slash ? str + 1 : str),
+    auto value = std::string((const char*) (leading_slash ? str + 1 : str),
-                        leading_slash ? len - 1 : len);
+                             leading_slash ? len - 1 : len);
     auto field_name = ypc->get_path_fragment(1);
 
     if (field_name == "file-pattern") {
@@ -286,8 +283,8 @@ static int
 read_levels(yajlpp_parse_context* ypc, const unsigned char* str, size_t len)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string regex = string((const char*) str, len);
+    auto regex = std::string((const char*) str, len);
-    string level_name_or_number = ypc->get_path_fragment(2);
+    auto level_name_or_number = ypc->get_path_fragment(2);
     log_level_t level = string2level(level_name_or_number.c_str());
     elf->elf_level_patterns[level].lp_regex = regex;
 
@@ -298,7 +295,7 @@ static int
 read_level_int(yajlpp_parse_context* ypc, long long val)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string level_name_or_number = ypc->get_path_fragment(2);
+    auto level_name_or_number = ypc->get_path_fragment(2);
     log_level_t level = string2level(level_name_or_number.c_str());
 
     elf->elf_level_pairs.emplace_back(val, level);
@@ -310,9 +307,9 @@ static int
 read_action_def(yajlpp_parse_context* ypc, const unsigned char* str, size_t len)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string action_name = ypc->get_path_fragment(2);
+    auto action_name = ypc->get_path_fragment(2);
-    string field_name = ypc->get_path_fragment(3);
+    auto field_name = ypc->get_path_fragment(3);
-    string val = string((const char*) str, len);
+    auto val = std::string((const char*) str, len);
 
     elf->lf_action_defs[action_name].ad_name = action_name;
     if (field_name == "label")
@@ -325,8 +322,8 @@ static int
 read_action_bool(yajlpp_parse_context* ypc, int val)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string action_name = ypc->get_path_fragment(2);
+    auto action_name = ypc->get_path_fragment(2);
-    string field_name = ypc->get_path_fragment(3);
+    auto field_name = ypc->get_path_fragment(3);
 
     elf->lf_action_defs[action_name].ad_capture_output = val;
 
@@ -337,9 +334,9 @@ static int
 read_action_cmd(yajlpp_parse_context* ypc, const unsigned char* str, size_t len)
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
-    string action_name = ypc->get_path_fragment(2);
+    auto action_name = ypc->get_path_fragment(2);
-    string field_name = ypc->get_path_fragment(3);
+    auto field_name = ypc->get_path_fragment(3);
-    string val = string((const char*) str, len);
+    auto val = std::string((const char*) str, len);
 
     elf->lf_action_defs[action_name].ad_name = action_name;
     elf->lf_action_defs[action_name].ad_cmdline.push_back(val);
@@ -368,7 +365,7 @@ read_json_constant(yajlpp_parse_context* ypc,
                    const unsigned char* str,
                    size_t len)
 {
-    auto val = string((const char*) str, len);
+    auto val = std::string((const char*) str, len);
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
 
     ypc->ypc_array_index.back() += 1;
@@ -386,7 +383,7 @@ create_search_table(yajlpp_parse_context* ypc,
 {
     auto elf = (external_log_format*) ypc->ypc_obj_stack.top();
     const intern_string_t table_name = ypc->get_path_fragment_i(2);
-    string regex = string((const char*) str, len);
+    auto regex = std::string((const char*) str, len);
 
     elf->elf_search_tables.emplace_back(table_name, regex);
 
@@ -810,7 +807,7 @@ struct json_path_container format_handlers = {
 static int
 read_id(yajlpp_parse_context* ypc, const unsigned char* str, size_t len)
 {
-    auto file_id = string((const char*) str, len);
+    auto file_id = std::string((const char*) str, len);
 
     if (find(SUPPORTED_FORMAT_SCHEMAS.begin(),
              SUPPORTED_FORMAT_SCHEMAS.end(),
@@ -927,7 +924,7 @@ format_error_reporter(const yajlpp_parse_context& ypc,
 
 std::vector<intern_string_t>
 load_format_file(const ghc::filesystem::path& filename,
-                 std::vector<string>& errors)
+                 std::vector<std::string>& errors)
 {
     std::vector<intern_string_t> retval;
     struct userdata ud;
@@ -985,7 +982,8 @@ load_format_file(const ghc::filesystem::path& filename,
 }
 
 static void
-load_from_path(const ghc::filesystem::path& path, std::vector<string>& errors)
+load_from_path(const ghc::filesystem::path& path,
+               std::vector<std::string>& errors)
 {
     auto format_path = path / "formats/*/*.json";
     static_root_mem<glob_t, globfree> gl;
@@ -999,8 +997,8 @@ load_from_path(const ghc::filesystem::path& path, std::vector<string>& errors)
                 continue;
             }
 
-            string filename(gl->gl_pathv[lpc]);
+            std::string filename(gl->gl_pathv[lpc]);
-            vector<intern_string_t> format_list;
+            std::vector<intern_string_t> format_list;
 
             format_list = load_format_file(filename, errors);
             if (format_list.empty()) {
@@ -1059,7 +1057,7 @@ load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
 
     uint8_t mod_counter = 0;
 
-    vector<std::shared_ptr<external_log_format>> alpha_ordered_formats;
+    std::vector<std::shared_ptr<external_log_format>> alpha_ordered_formats;
     for (auto iter = LOG_FORMATS.begin(); iter != LOG_FORMATS.end(); ++iter) {
         auto& elf = iter->second;
         elf->build(errors);
@@ -1096,7 +1094,7 @@ load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
     auto& graph_ordered_formats = external_log_format::GRAPH_ORDERED_FORMATS;
 
     while (!alpha_ordered_formats.empty()) {
-        vector<intern_string_t> popped_formats;
+        std::vector<intern_string_t> popped_formats;
 
         for (auto iter = alpha_ordered_formats.begin();
              iter != alpha_ordered_formats.end();)
@@ -1156,7 +1154,7 @@ load_formats(const std::vector<ghc::filesystem::path>& extra_paths,
 static void
 exec_sql_in_path(sqlite3* db,
                  const ghc::filesystem::path& path,
-                 std::vector<string>& errors)
+                 std::vector<std::string>& errors)
 {
     auto format_path = path / "formats/*/*.sql";
     static_root_mem<glob_t, globfree> gl;
@@ -1216,7 +1214,7 @@ extract_metadata(const char* contents,
     if (!meta_out.sm_synopsis.empty()) {
         size_t space = meta_out.sm_synopsis.find(' ');
 
-        if (space == string::npos) {
+        if (space == std::string::npos) {
             space = meta_out.sm_synopsis.size();
         }
         meta_out.sm_name = meta_out.sm_synopsis.substr(0, space);
@@ -1253,7 +1251,7 @@ find_format_in_path(const ghc::filesystem::path& path,
     if (glob(format_path.c_str(), 0, nullptr, gl.inout()) == 0) {
         for (int lpc = 0; lpc < (int) gl->gl_pathc; lpc++) {
             const char* filename = basename(gl->gl_pathv[lpc]);
-            string script_name = string(filename, strlen(filename) - 5);
+            auto script_name = std::string(filename, strlen(filename) - 5);
             struct script_metadata meta;
 
             meta.sm_path = gl->gl_pathv[lpc];
@@ -1267,7 +1265,7 @@ find_format_in_path(const ghc::filesystem::path& path,
 }
 
 void
-find_format_scripts(const vector<ghc::filesystem::path>& extra_paths,
+find_format_scripts(const std::vector<ghc::filesystem::path>& extra_paths,
                     available_scripts& scripts)
 {
     for (const auto& extra_path : extra_paths) {

src/log_vtab_impl.cc

@@ -38,8 +38,6 @@
 #include "yajlpp/json_op.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
-
 static auto intern_lifetime = intern_string::get_table_lifetime();
 
 static struct log_cursor log_cursor_latest;
@@ -106,7 +104,7 @@ log_vtab_impl::get_table_statement()
     for (iter = cols.begin(); iter != cols.end(); iter++) {
         auto_mem<char, sqlite3_free> coldecl;
         auto_mem<char, sqlite3_free> colname;
-        string comment;
+        std::string comment;
 
         require(!iter->vc_name.empty());
 
@@ -132,7 +130,7 @@ log_vtab_impl::get_table_statement()
     return oss.str();
 }
 
-pair<int, unsigned int>
+std::pair<int, unsigned int>
 log_vtab_impl::logline_value_to_sqlite_type(value_kind_t kind)
 {
     int type = 0;
@@ -164,7 +162,7 @@ log_vtab_impl::logline_value_to_sqlite_type(value_kind_t kind)
             ensure(0);
             break;
     }
-    return make_pair(type, subtype);
+    return std::make_pair(type, subtype);
 }
 
 struct vtab {
@@ -322,7 +320,7 @@ vt_column(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int col)
     content_line_t cl(vt->lss->at(vc->log_cursor.lc_curr_line));
     uint64_t line_number;
     auto ld = vt->lss->find_data(cl, line_number);
-    shared_ptr<logfile> lf = (*ld)->get_file();
+    auto lf = (*ld)->get_file();
     auto ll = lf->begin() + line_number;
 
     require(col >= 0);
@@ -419,8 +417,8 @@ vt_column(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int col)
             } else {
                 content_line_t prev_cl(
                     vt->lss->at(vis_line_t(vc->log_cursor.lc_curr_line - 1)));
-                shared_ptr<logfile> prev_lf = vt->lss->find(prev_cl);
+                auto prev_lf = vt->lss->find(prev_cl);
-                logfile::iterator prev_ll = prev_lf->begin() + prev_cl;
+                auto prev_ll = prev_lf->begin() + prev_cl;
                 uint64_t prev_time, curr_line_time;
 
                 prev_time = prev_ll->get_time() * 1000ULL;
@@ -460,8 +458,7 @@ vt_column(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int col)
         }
 
         case VT_COL_LOG_TAGS: {
-            const map<content_line_t, bookmark_metadata>& bm
+            const auto& bm = vt->lss->get_user_bookmark_metadata();
-                = vt->lss->get_user_bookmark_metadata();
 
             auto bm_iter = bm.find(vt->lss->at(vc->log_cursor.lc_curr_line));
             if (bm_iter == bm.end() || bm_iter->second.bm_tags.empty()) {
@@ -535,7 +532,7 @@ vt_column(sqlite3_vtab_cursor* cur, sqlite3_context* ctx, int col)
                         break;
                     }
                     case 1: {
-                        const string& fn = lf->get_filename();
+                        const auto& fn = lf->get_filename();
 
                         sqlite3_result_text(
                             ctx, fn.c_str(), fn.length(), SQLITE_STATIC);
@@ -984,7 +981,7 @@ vt_update(sqlite3_vtab* tab,
         bookmark_metadata tmp_bm;
 
         if (log_tags) {
-            vector<string> errors;
+            std::vector<std::string> errors;
             yajlpp_parse_context ypc(log_vtab_data.lvd_source, &tags_handler);
             auto_mem<yajl_handle_t> handle(yajl_free);
 
@@ -995,8 +992,8 @@ vt_update(sqlite3_vtab* tab,
                 .with_error_reporter([](const yajlpp_parse_context& ypc,
                                         lnav_log_level_t level,
                                         const char* msg) {
-                    vector<string>& errors
+                    auto& errors
-                        = *((vector<string>*) ypc.ypc_userdata);
+                        = *((std::vector<std::string>*) ypc.ypc_userdata);
                     errors.emplace_back(msg);
                 })
                 .with_obj(tmp_bm);
@@ -1026,12 +1023,12 @@ vt_update(sqlite3_vtab* tab,
 
             vt->tc->set_user_mark(&textview_curses::BM_META, vrowid, true);
             if (part_name) {
-                line_meta.bm_name = string((const char*) part_name);
+                line_meta.bm_name = std::string((const char*) part_name);
             } else {
                 line_meta.bm_name.clear();
             }
             if (log_comment) {
-                line_meta.bm_comment = string((const char*) log_comment);
+                line_meta.bm_comment = std::string((const char*) log_comment);
             } else {
                 line_meta.bm_comment.clear();
             }
@@ -1125,10 +1122,10 @@ log_vtab_manager::~log_vtab_manager()
     }
 }
 
-string
+std::string
 log_vtab_manager::register_vtab(std::shared_ptr<log_vtab_impl> vi)
 {
-    string retval;
+    std::string retval;
 
     if (this->vm_impls.find(vi->get_name()) == this->vm_impls.end()) {
         auto_mem<char, sqlite3_free> errmsg;
@@ -1153,10 +1150,10 @@ log_vtab_manager::register_vtab(std::shared_ptr<log_vtab_impl> vi)
     return retval;
 }
 
-string
+std::string
 log_vtab_manager::unregister_vtab(intern_string_t name)
 {
-    string retval;
+    std::string retval;
 
     if (this->vm_impls.find(name) == this->vm_impls.end()) {
         retval = fmt::format(FMT_STRING("unknown log line table -- {}"), name);

src/logfile.cc

@@ -33,7 +33,6 @@
 
 #include "logfile.hh"
 
-#include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
@@ -51,8 +50,6 @@
 #include "log_format.hh"
 #include "logfile.cfg.hh"
 
-using namespace std;
-
 static auto intern_lifetime = intern_string::get_table_lifetime();
 
 static const size_t INDEX_RESERVE_INCREMENT = 1024;
@@ -126,7 +123,7 @@ logfile::open(std::string filename, logfile_open_options& loo)
     return Ok(lf);
 }
 
-logfile::logfile(string filename, logfile_open_options& loo)
+logfile::logfile(std::string filename, logfile_open_options& loo)
     : lf_filename(std::move(filename)), lf_options(std::move(loo))
 {
 }
@@ -195,14 +192,13 @@ logfile::process_prefix(shared_buffer_ref& sbr, const line_info& li)
                    < injector::get<const lnav::logfile::config&>()
                          .lc_max_unrecognized_lines)
     {
-        auto& root_formats = log_format::get_root_formats();
+        const auto& root_formats = log_format::get_root_formats();
-        vector<std::shared_ptr<log_format>>::iterator iter;
 
         /*
          * Try each scanner until we get a match.  Fortunately, all the formats
          * are sufficiently different that there are no ambiguities...
          */
-        for (iter = root_formats.begin();
+        for (auto iter = root_formats.begin();
              iter != root_formats.end() && (found != log_format::SCAN_MATCH);
              ++iter)
         {
@@ -647,7 +643,7 @@ logfile::read_line(logfile::iterator ll)
                 return sbr;
             });
     } catch (line_buffer::error& e) {
-        return Err(string(strerror(e.e_err)));
+        return Err(std::string(strerror(e.e_err)));
     }
 }
 
@@ -792,7 +788,7 @@ logfile::find_from_time(const timeval& tv) const
 }
 
 void
-logfile::mark_as_duplicate(const string& name)
+logfile::mark_as_duplicate(const std::string& name)
 {
     this->lf_indexing = false;
     this->lf_options.loo_is_visible = false;

src/logfile.hh

@@ -1,3 +1,4 @@
+
 /**
  * Copyright (c) 2007-2012, Timothy Stack
  *

src/logfile_fwd.hh

@@ -35,7 +35,7 @@
 #include <chrono>
 #include <string>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "file_format.hh"
 
 using ui_clock = std::chrono::steady_clock;
@@ -52,20 +52,51 @@ enum class logfile_name_source {
     REMOTE,
 };
 
-struct logfile_open_options {
+struct logfile_open_options_base {
+    std::string loo_filename;
+    logfile_name_source loo_source{logfile_name_source::USER};
+    bool loo_temp_file{false};
+    dev_t loo_temp_dev{0};
+    ino_t loo_temp_ino{0};
+    bool loo_detect_format{true};
+    bool loo_include_in_session{true};
+    bool loo_is_visible{true};
+    bool loo_non_utf_is_visible{true};
+    ssize_t loo_visible_size_limit{-1};
+    bool loo_tail{true};
+    file_format_t loo_file_format{file_format_t::UNKNOWN};
+};
+
+struct logfile_open_options : public logfile_open_options_base {
+    logfile_open_options() = default;
+
+    explicit logfile_open_options(const logfile_open_options_base& base)
+        : logfile_open_options_base(base)
+    {
+    }
+
     logfile_open_options& with_filename(const std::string& val)
     {
         this->loo_filename = val;
 
         return *this;
-    };
+    }
 
     logfile_open_options& with_fd(auto_fd fd)
     {
         this->loo_fd = std::move(fd);
+        this->loo_temp_file = true;
 
         return *this;
-    };
+    }
+
+    logfile_open_options& with_stat_for_temp(const struct stat& st)
+    {
+        this->loo_temp_dev = st.st_dev;
+        this->loo_temp_ino = st.st_ino;
+
+        return *this;
+    }
 
     logfile_open_options& with_source(logfile_name_source src)
     {
@@ -79,7 +110,7 @@ struct logfile_open_options {
         this->loo_detect_format = val;
 
         return *this;
-    };
+    }
 
     logfile_open_options& with_include_in_session(bool val)
     {
@@ -123,16 +154,7 @@ struct logfile_open_options {
         return *this;
     }
 
-    std::string loo_filename;
     auto_fd loo_fd;
-    logfile_name_source loo_source{logfile_name_source::USER};
-    bool loo_detect_format{true};
-    bool loo_include_in_session{true};
-    bool loo_is_visible{true};
-    bool loo_non_utf_is_visible{true};
-    ssize_t loo_visible_size_limit{-1};
-    bool loo_tail{true};
-    file_format_t loo_file_format{file_format_t::UNKNOWN};
 };
 
 #endif

src/logfile_sub_source.cc

@@ -46,8 +46,6 @@
 #include "sql_util.hh"
 #include "yajlpp/yajlpp.hh"
 
-using namespace std;
-
 const bookmark_type_t logfile_sub_source::BM_ERRORS("error");
 const bookmark_type_t logfile_sub_source::BM_WARNINGS("warning");
 const bookmark_type_t logfile_sub_source::BM_FILES("");
@@ -77,19 +75,19 @@ pretty_sql_callback(exec_context& ec, sqlite3_stmt* stmt)
     return 0;
 }
 
-static future<string>
+static std::future<std::string>
-pretty_pipe_callback(exec_context& ec, const string& cmdline, auto_fd& fd)
+pretty_pipe_callback(exec_context& ec, const std::string& cmdline, auto_fd& fd)
 {
     auto retval = std::async(std::launch::async, [&]() {
         char buffer[1024];
-        ostringstream ss;
+        std::ostringstream ss;
         ssize_t rc;
 
         while ((rc = read(fd, buffer, sizeof(buffer))) > 0) {
             ss.write(buffer, rc);
         }
 
-        string retval = ss.str();
+        auto retval = ss.str();
 
         if (endswith(retval, "\n")) {
             retval.resize(retval.length() - 1);
@@ -109,11 +107,11 @@ logfile_sub_source::logfile_sub_source()
     this->clear_min_max_log_times();
 }
 
-shared_ptr<logfile>
+std::shared_ptr<logfile>
 logfile_sub_source::find(const char* fn, content_line_t& line_base)
 {
     iterator iter;
-    shared_ptr<logfile> retval = nullptr;
+    std::shared_ptr<logfile> retval = nullptr;
 
     line_base = content_line_t(0);
     for (iter = this->lss_files.begin();
@@ -153,7 +151,7 @@ logfile_sub_source::find_from_time(const struct timeval& start) const
 void
 logfile_sub_source::text_value_for_line(textview_curses& tc,
                                         int row,
-                                        string& value_out,
+                                        std::string& value_out,
                                         line_flags_t flags)
 {
     content_line_t line(0);
@@ -164,7 +162,7 @@ logfile_sub_source::text_value_for_line(textview_curses& tc,
     line = this->at(vis_line_t(row));
 
     if (flags & RF_RAW) {
-        shared_ptr<logfile> lf = this->find(line);
+        auto lf = this->find(line);
         value_out = lf->read_line(lf->begin() + line)
                         .map([](auto sbr) { return to_string(sbr); })
                         .unwrapOr({});
@@ -221,10 +219,10 @@ logfile_sub_source::text_value_for_line(textview_curses& tc,
     if (flags & RF_REWRITE) {
         exec_context ec(
             &this->lss_token_values, pretty_sql_callback, pretty_pipe_callback);
-        string rewritten_line;
+        std::string rewritten_line;
 
         ec.with_perms(exec_context::perm_t::READ_ONLY);
-        ec.ec_local_vars.push(map<string, string>());
+        ec.ec_local_vars.push(std::map<std::string, std::string>());
         ec.ec_top_line = vis_line_t(row);
         add_ansi_vars(ec.ec_global_vars);
         add_global_vars(ec);
@@ -438,8 +436,9 @@ logfile_sub_source::text_attrs_for_line(textview_curses& lv,
             bookmark_vector<vis_line_t>& bv_search
                 = bm[&textview_curses::BM_SEARCH];
 
-            if (binary_search(
+            if (binary_search(std::begin(bv_search),
-                    ::begin(bv_search), ::end(bv_search), vis_line_t(row))) {
+                              std::end(bv_search),
+                              vis_line_t(row))) {
                 lr.lr_start = 0;
                 lr.lr_end = 1;
                 value_out.emplace_back(lr, &view_curses::VC_STYLE, A_REVERSE);
@@ -503,6 +502,9 @@ logfile_sub_source::text_attrs_for_line(textview_curses& lv,
     value_out.emplace_back(
         lr, &SA_FORMAT, this->lss_token_file->get_format()->get_name());
 
+    value_out.emplace_back(
+        lr, SA_FORMAT2.value(this->lss_token_file->get_format()->get_name()));
+
     {
         const auto& bv = lv.get_bookmarks()[&textview_curses::BM_META];
         bookmark_vector<vis_line_t>::const_iterator bv_iter;
@@ -779,10 +781,10 @@ logfile_sub_source::rebuild_index(
             remaining += lf->size() - ld.ld_lines_indexed;
         }
 
-        auto row_iter = lower_bound(this->lss_index.begin(),
+        auto row_iter = std::lower_bound(this->lss_index.begin(),
-                                    this->lss_index.end(),
+                                         this->lss_index.end(),
-                                    *lowest_tv,
+                                         *lowest_tv,
-                                    logline_cmp(*this));
+                                         logline_cmp(*this));
         this->lss_index.shrink_to(
             std::distance(this->lss_index.begin(), row_iter));
         log_debug("new index size %ld/%ld; remain %ld",
@@ -862,7 +864,8 @@ logfile_sub_source::rebuild_index(
             if (this->lss_sorting_observer) {
                 this->lss_sorting_observer(*this, 0, this->lss_index.size());
             }
-            sort(this->lss_index.begin(), this->lss_index.end(), line_cmper);
+            std::sort(
+                this->lss_index.begin(), this->lss_index.end(), line_cmper);
             if (this->lss_sorting_observer) {
                 this->lss_sorting_observer(
                     *this, this->lss_index.size(), this->lss_index.size());
@@ -1011,7 +1014,7 @@ logfile_sub_source::rebuild_index(
 void
 logfile_sub_source::text_update_marks(vis_bookmarks& bm)
 {
-    shared_ptr<logfile> last_file = nullptr;
+    std::shared_ptr<logfile> last_file;
     vis_line_t vl;
 
     bm[&BM_WARNINGS].clear();
@@ -1025,9 +1028,7 @@ logfile_sub_source::text_update_marks(vis_bookmarks& bm)
     for (; vl < (int) this->lss_filtered_index.size(); ++vl) {
         const content_line_t orig_cl = this->at(vl);
         content_line_t cl = orig_cl;
-        shared_ptr<logfile> lf;
+        auto lf = this->find(cl);
-
-        lf = this->find(cl);
 
         for (auto& lss_user_mark : this->lss_user_marks) {
             if (binary_search(lss_user_mark.second.begin(),
@@ -1201,15 +1202,16 @@ logfile_sub_source::list_input_handle_key(listview_curses& lv, int ch)
 }
 
 nonstd::optional<
-    pair<grep_proc_source<vis_line_t>*, grep_proc_sink<vis_line_t>*>>
+    std::pair<grep_proc_source<vis_line_t>*, grep_proc_sink<vis_line_t>*>>
 logfile_sub_source::get_grepper()
 {
-    return make_pair((grep_proc_source<vis_line_t>*) &this->lss_meta_grepper,
+    return std::make_pair(
-                     (grep_proc_sink<vis_line_t>*) &this->lss_meta_grepper);
+        (grep_proc_source<vis_line_t>*) &this->lss_meta_grepper,
+        (grep_proc_sink<vis_line_t>*) &this->lss_meta_grepper);
 }
 
 bool
-logfile_sub_source::insert_file(const shared_ptr<logfile>& lf)
+logfile_sub_source::insert_file(const std::shared_ptr<logfile>& lf)
 {
     iterator existing;
 
@@ -1368,7 +1370,7 @@ logfile_sub_source::eval_sql_filter(sqlite3_stmt* stmt,
     lf->read_full_message(ll, sbr);
     auto format = lf->get_format();
     string_attrs_t sa;
-    vector<logline_value> values;
+    std::vector<logline_value> values;
     format->annotate(std::distance(lf->cbegin(), ll), sbr, sa, values);
 
     sqlite3_reset(stmt);
@@ -1829,7 +1831,7 @@ sql_filter::to_command() const
 
 bool
 logfile_sub_source::meta_grepper::grep_value_for_line(vis_line_t line,
-                                                      string& value_out)
+                                                      std::string& value_out)
 {
     content_line_t cl = this->lmg_source.at(vis_line_t(line));
     std::map<content_line_t, bookmark_metadata>& user_mark_meta

src/network-extension-functions.cc

@@ -41,9 +41,7 @@
 #include "sqlite3.h"
 #include "vtab_module.hh"
 
-using namespace std;
+static std::string
-
-static string
 sql_gethostbyname(const char* name_in)
 {
     char buffer[INET6_ADDRSTRLEN];
@@ -84,7 +82,7 @@ sql_gethostbyname(const char* name_in)
     return buffer;
 }
 
-static string
+static std::string
 sql_gethostbyaddr(const char* addr_str)
 {
     union {

src/papertrail_proc.hh

@@ -45,8 +45,8 @@
 #    include <sys/wait.h>
 #    include <unistd.h>
 
-#    include "auto_fd.hh"
 #    include "auto_mem.hh"
+#    include "base/auto_fd.hh"
 #    include "curl_looper.hh"
 #    include "line_buffer.hh"
 #    include "yajlpp/yajlpp.hh"
@@ -117,7 +117,7 @@ public:
 
     auto_fd copy_fd() const
     {
-        return this->ptp_fd;
+        return this->ptp_fd.dup();
     };
 
     long complete(CURLcode result);

src/pcap_manager.cc

@@ -59,7 +59,7 @@ convert(const std::string& filename)
         auto dev_null = open("/dev/null", O_RDONLY);
 
         dup2(dev_null, STDIN_FILENO);
-        dup2(outfile.second, STDOUT_FILENO);
+        dup2(outfile.second.release(), STDOUT_FILENO);
         setenv("TZ", "UTC", 1);
 
         const char* args[] = {
@@ -131,7 +131,7 @@ convert(const std::string& filename)
 
     return Ok(convert_result{
         std::move(child),
-        auto_fd(outfile.second),
+        std::move(outfile.second),
         error_queue,
     });
 }

src/pcap_manager.hh

@@ -35,7 +35,7 @@
 #include <string>
 #include <vector>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/auto_pid.hh"
 #include "base/result.h"
 

src/pcrepp/pcrepp.cc

@@ -31,8 +31,6 @@
 
 #include "pcrepp.hh"
 
-using namespace std;
-
 const int JIT_STACK_MIN_SIZE = 32 * 1024;
 const int JIT_STACK_MAX_SIZE = 512 * 1024;
 
@@ -87,7 +85,7 @@ void
 pcrepp::find_captures(const char* pattern)
 {
     bool in_class = false, in_escape = false, in_literal = false;
-    vector<pcre_context::capture> cap_in_progress;
+    std::vector<pcre_context::capture> cap_in_progress;
 
     for (int lpc = 0; pattern[lpc]; lpc++) {
         if (in_escape) {

src/piper_proc.cc

@@ -45,8 +45,6 @@
 #include "config.h"
 #include "line_buffer.hh"
 
-using namespace std;
-
 static const char* STDIN_EOF_MSG = "---- END-OF-STDIN ----";
 
 static ssize_t
@@ -64,10 +62,11 @@ write_timestamp(int fd, off_t woff)
     return pwrite(fd, time_str, strlen(time_str), woff);
 }
 
-piper_proc::piper_proc(int pipefd, bool timestamp, int filefd)
+piper_proc::piper_proc(auto_fd pipefd, bool timestamp, auto_fd filefd)
-    : pp_fd(filefd), pp_child(-1)
+    : pp_fd(std::move(filefd)), pp_child(-1)
 {
-    require(pipefd >= 0);
+    require(pipefd.get() >= 0);
+    require(this->pp_fd.get() >= 0);
 
     log_perror(fcntl(this->pp_fd.get(), F_SETFD, FD_CLOEXEC));
 
@@ -77,7 +76,6 @@ piper_proc::piper_proc(int pipefd, bool timestamp, int filefd)
             throw error(errno);
 
         case 0: {
-            auto_fd infd(pipefd);
             line_buffer lb;
             off_t woff = 0, last_woff = 0;
             file_range last_range;
@@ -101,8 +99,8 @@ piper_proc::piper_proc(int pipefd, bool timestamp, int filefd)
                     close(fd_to_close);
                 }
             }
-            log_perror(fcntl(infd.get(), F_SETFL, O_NONBLOCK));
+            log_perror(fcntl(pipefd.get(), F_SETFL, O_NONBLOCK));
-            lb.set_fd(infd);
+            lb.set_fd(pipefd);
             do {
                 struct pollfd pfd = {lb.get_fd(), POLLIN, 0};
 

src/piper_proc.hh

@@ -36,7 +36,7 @@
 
 #include <sys/types.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 
 /**
  * Creates a subprocess that reads data from a pipe and writes it to a file so
@@ -62,7 +62,7 @@ public:
      *   the lines read from pipefd.
      * @param filefd The descriptor for the backing file.
      */
-    piper_proc(int pipefd, bool timestamp, int filefd);
+    piper_proc(auto_fd pipefd, bool timestamp, auto_fd filefd);
 
     bool has_exited();
 
@@ -74,7 +74,7 @@ public:
     /** @return The file descriptor for the temporary file. */
     auto_fd get_fd()
     {
-        return std::move(this->pp_fd);
+        return this->pp_fd.dup();
     };
 
     pid_t get_child_pid() const

src/readline_callbacks.cc

@@ -49,8 +49,6 @@
 #include "vtab_module.hh"
 #include "yajlpp/yajlpp.hh"
 
-using namespace std;
-
 #define ABORT_MSG "(Press " ANSI_BOLD("CTRL+]") " to abort)"
 
 #define STR_HELPER(x) #x
@@ -179,10 +177,10 @@ rl_sql_help(readline_curses* rc)
 
         for (const auto& ht : avail_help) {
             format_help_text_for_term(
-                *ht, min(70UL, doc_width), doc_al, help_count > 1);
+                *ht, std::min(70UL, doc_width), doc_al, help_count > 1);
             if (help_count == 1) {
                 format_example_text_for_term(
-                    *ht, eval_example, min(70UL, ex_width), ex_al);
+                    *ht, eval_example, std::min(70UL, ex_width), ex_al);
             }
         }
 
@@ -204,7 +202,7 @@ rl_sql_help(readline_curses* rc)
         auto intern_ident = intern_string::lookup(ident);
         auto vtab = lnav_data.ld_vtab_manager->lookup_impl(intern_ident);
         auto vtab_module_iter = vtab_module_ddls.find(intern_ident);
-        string ddl;
+        std::string ddl;
 
         if (vtab != nullptr) {
             ddl = trim(vtab->get_table_statement());
@@ -250,11 +248,11 @@ rl_change(readline_curses* rc)
 
     switch (lnav_data.ld_mode) {
         case LNM_COMMAND: {
-            static string last_command;
+            static std::string last_command;
             static int generation = 0;
 
-            string line = rc->get_line_buffer();
+            const auto line = rc->get_line_buffer();
-            vector<string> args;
+            std::vector<std::string> args;
             auto iter = lnav_commands.end();
 
             split_ws(line, args);
@@ -336,7 +334,7 @@ rl_change(readline_curses* rc)
                     attr_line_t al;
 
                     dtc.get_dimensions(height, width);
-                    format_help_text_for_term(ht, min(70UL, width), al);
+                    format_help_text_for_term(ht, std::min(70UL, width), al);
                     lnav_data.ld_doc_source.replace_with(al);
                     dtc.set_needs_update();
 
@@ -349,7 +347,7 @@ rl_change(readline_curses* rc)
 
                 if (cmd.c_prompt != nullptr && generation == 0
                     && trim(line) == args[0]) {
-                    string new_prompt
+                    const auto new_prompt
                         = cmd.c_prompt(lnav_data.ld_exec_context, line);
 
                     if (!new_prompt.empty()) {
@@ -363,9 +361,9 @@ rl_change(readline_curses* rc)
             break;
         }
         case LNM_EXEC: {
-            string line = rc->get_line_buffer();
+            const auto line = rc->get_line_buffer();
             size_t name_end = line.find(' ');
-            string script_name = line.substr(0, name_end);
+            const auto script_name = line.substr(0, name_end);
             auto& scripts = injector::get<available_scripts&>();
             auto iter = scripts.as_scripts.find(script_name);
 
@@ -395,8 +393,8 @@ static void
 rl_search_internal(readline_curses* rc, ln_mode_t mode, bool complete = false)
 {
     textview_curses* tc = get_textview_for_mode(mode);
-    string term_val;
+    std::string term_val;
-    string name;
+    std::string name;
 
     tc->get_highlights().erase({highlight_source_t::PREVIEW, "preview"});
     tc->get_highlights().erase({highlight_source_t::PREVIEW, "bodypreview"});
@@ -520,7 +518,7 @@ lnav_rl_abort(readline_curses* rc)
     tc->get_highlights().erase({highlight_source_t::PREVIEW, "bodypreview"});
     lnav_data.ld_log_source.set_preview_sql_filter(nullptr);
 
-    vector<string> errors;
+    std::vector<std::string> errors;
     lnav_config = rollback_lnav_config;
     reload_config(errors);
 
@@ -545,7 +543,7 @@ rl_callback_int(readline_curses* rc, bool is_alt)
 {
     textview_curses* tc = get_textview_for_mode(lnav_data.ld_mode);
     exec_context& ec = lnav_data.ld_exec_context;
-    string alt_msg;
+    std::string alt_msg;
 
     lnav_data.ld_bottom_source.set_prompt("");
     lnav_data.ld_doc_source.clear();
@@ -649,7 +647,7 @@ rl_callback_int(readline_curses* rc, bool is_alt)
         case LNM_SQL: {
             auto result = execute_sql(ec, rc->get_value(), alt_msg);
             db_label_source& dls = lnav_data.ld_db_row_source;
-            string prompt;
+            std::string prompt;
 
             if (result.isOk()) {
                 auto msg = result.unwrap();
@@ -675,24 +673,25 @@ rl_callback_int(readline_curses* rc, bool is_alt)
             tmpout = std::tmpfile();
 
             if (!tmpout) {
-                rc->set_value("Unable to open temporary output file: "
+                rc->set_value(fmt::format(
-                              + string(strerror(errno)));
+                    FMT_STRING("Unable to open temporary output file: {}"),
+                    strerror(errno)));
             } else {
                 auto fd_copy = auto_fd::dup_of(fileno(tmpout));
                 char desc[256], timestamp[32];
                 time_t current_time = time(nullptr);
-                string path_and_args = rc->get_value();
+                const auto path_and_args = rc->get_value();
 
                 {
                     exec_context::output_guard og(
                         ec, "tmp", std::make_pair(tmpout.release(), fclose));
 
-                    string result = execute_file(ec, path_and_args)
+                    auto result = execute_file(ec, path_and_args)
-                                        .map(ok_prefix)
+                                      .map(ok_prefix)
-                                        .orElse(err_to_ok)
+                                      .orElse(err_to_ok)
-                                        .unwrap();
+                                      .unwrap();
-                    string::size_type lf_index = result.find('\n');
+                    auto lf_index = result.find('\n');
-                    if (lf_index != string::npos) {
+                    if (lf_index != std::string::npos) {
                         result = result.substr(0, lf_index);
                     }
                     rc->set_value(result);
@@ -711,7 +710,7 @@ rl_callback_int(readline_curses* rc, bool is_alt)
                              path_and_args.c_str(),
                              timestamp);
                     lnav_data.ld_active_files.fc_file_names[desc]
-                        .with_fd(fd_copy)
+                        .with_fd(std::move(fd_copy))
                         .with_include_in_session(false)
                         .with_detect_format(false);
                     lnav_data.ld_files_to_front.emplace_back(desc, 0);
@@ -751,12 +750,12 @@ rl_display_matches(readline_curses* rc)
     getmaxyx(lnav_data.ld_window, height, width);
 
     max_len = rc->get_max_match_length() + 2;
-    cols = max(1UL, width / max_len);
+    cols = std::max(1UL, width / max_len);
 
     if (matches.empty()) {
         lnav_data.ld_match_source.clear();
     } else {
-        string current_match = rc->get_match_string();
+        const auto current_match = rc->get_match_string();
         int curr_col = 0;
         attr_line_t al;
         bool add_nl = false;

src/readline_curses.cc

@@ -66,8 +66,6 @@
 #include "shlex.hh"
 #include "spookyhash/SpookyV2.h"
 
-using namespace std;
-
 static int got_line = 0;
 static bool alt_done = 0;
 static sig_atomic_t got_timeout = 0;
@@ -93,8 +91,8 @@ static const char* RL_INIT[] = {
 };
 
 readline_context* readline_context::loaded_context;
-set<string>* readline_context::arg_possibilities;
+std::set<std::string>* readline_context::arg_possibilities;
-static string last_match_str;
+static std::string last_match_str;
 static bool last_match_str_valid;
 static bool arg_needs_shlex;
 static nonstd::optional<std::string> rewrite_line_start;
@@ -226,9 +224,9 @@ recvstring(int sock, char* buf, size_t len)
 char*
 readline_context::completion_generator(const char* text_in, int state)
 {
-    static vector<string> matches;
+    static std::vector<std::string> matches;
 
-    vector<string> long_matches;
+    std::vector<std::string> long_matches;
     char* retval = nullptr;
 
     if (state == 0) {
@@ -236,7 +234,7 @@ readline_context::completion_generator(const char* text_in, int state)
 
         if (arg_needs_shlex) {
             shlex arg_lexer(text_str);
-            map<string, string> scope;
+            std::map<std::string, std::string> scope;
             std::string result;
 
             if (arg_lexer.eval(result, scope)) {
@@ -281,11 +279,11 @@ readline_context::completion_generator(const char* text_in, int state)
             }
 
             if (matches.empty()) {
-                vector<pair<int, string>> fuzzy_matches;
+                std::vector<std::pair<int, std::string>> fuzzy_matches;
-                vector<pair<int, string>> fuzzy_long_matches;
+                std::vector<std::pair<int, std::string>> fuzzy_long_matches;
 
                 for (const auto& poss : (*arg_possibilities)) {
-                    string poss_str = tolower(poss);
+                    std::string poss_str = tolower(poss);
                     int score;
 
                     if (fts::fuzzy_match(
@@ -372,14 +370,14 @@ readline_context::attempted_completion(const char* text, int start, int end)
         rl_completion_append_character = loaded_context->rc_append_character;
     } else {
         char* space;
-        string cmd;
+        std::string cmd;
-        vector<string> prefix;
+        std::vector<std::string> prefix;
         int point = rl_point;
         while (point > 0 && rl_line_buffer[point] != ' ') {
             point -= 1;
         }
         shlex lexer(rl_line_buffer, point);
-        map<string, string> scope;
+        std::map<std::string, std::string> scope;
 
         arg_possibilities = nullptr;
         rl_completion_append_character = 0;
@@ -400,7 +398,7 @@ readline_context::attempted_completion(const char* text, int start, int end)
             if (space == nullptr) {
                 space = rl_line_buffer + strlen(rl_line_buffer);
             }
-            cmd = string(rl_line_buffer, space - rl_line_buffer);
+            cmd = std::string(rl_line_buffer, space - rl_line_buffer);
 
             auto iter = loaded_context->rc_prototypes.find(cmd);
 
@@ -414,7 +412,8 @@ readline_context::attempted_completion(const char* text, int start, int end)
                         = loaded_context->rc_append_character;
                 }
             } else {
-                vector<string>& proto = loaded_context->rc_prototypes[cmd];
+                std::vector<std::string>& proto
+                    = loaded_context->rc_prototypes[cmd];
 
                 if (proto.empty()) {
                     arg_possibilities = nullptr;
@@ -428,7 +427,7 @@ readline_context::attempted_completion(const char* text, int start, int end)
                     const auto& last_fn = fn_list.size() <= 1 ? ""
                                                               : fn_list.back();
 
-                    if (last_fn.find(':') != string::npos) {
+                    if (last_fn.find(':') != std::string::npos) {
                         auto rp_iter = loaded_context->rc_possibilities.find(
                             "remote-path");
                         if (rp_iter != loaded_context->rc_possibilities.end()) {
@@ -630,7 +629,7 @@ readline_curses::store_matches(char** matches, int num_matches, int max_len)
 
     max_len = 0;
     for (int lpc = 0; lpc <= num_matches; lpc++) {
-        max_len = max(max_len, (int) strlen(matches[lpc]));
+        max_len = std::max(max_len, (int) strlen(matches[lpc]));
     }
 
     if (last_match_str_valid && strcmp(last_match_str.c_str(), matches[0]) == 0)
@@ -742,7 +741,7 @@ readline_curses::start()
         child_this = this;
     }
 
-    map<int, readline_context*>::iterator current_context;
+    std::map<int, readline_context*>::iterator current_context;
     int maxfd;
 
     require(!this->rc_contexts.empty());
@@ -751,7 +750,7 @@ readline_curses::start()
 
     current_context = this->rc_contexts.end();
 
-    maxfd = max(STDIN_FILENO, this->rc_command_pipe[RCF_SLAVE].get());
+    maxfd = std::max(STDIN_FILENO, this->rc_command_pipe[RCF_SLAVE].get());
 
     while (looping) {
         fd_set ready_rfds;
@@ -928,8 +927,9 @@ readline_curses::start()
                     {
                         require(this->rc_contexts[context] != nullptr);
 
-                        this->rc_contexts[context]->rc_prefixes[string(type)]
+                        this->rc_contexts[context]
-                            = string(&msg[prompt_start]);
+                            ->rc_prefixes[std::string(type)]
+                            = std::string(&msg[prompt_start]);
                     } else if (sscanf(msg,
                                       "ap:%d:%31[^:]:%n",
                                       &context,
@@ -939,7 +939,7 @@ readline_curses::start()
                         require(this->rc_contexts[context] != nullptr);
 
                         this->rc_contexts[context]->add_possibility(
-                            string(type), string(&msg[prompt_start]));
+                            std::string(type), std::string(&msg[prompt_start]));
                         if (rl_last_func == rl_complete
                             || rl_last_func == rl_menu_complete) {
                             rl_last_func = NULL;
@@ -953,7 +953,7 @@ readline_curses::start()
                         require(this->rc_contexts[context] != nullptr);
 
                         this->rc_contexts[context]->rem_possibility(
-                            string(type), string(&msg[prompt_start]));
+                            std::string(type), std::string(&msg[prompt_start]));
                     } else if (sscanf(msg, "cpre:%d", &context) == 1) {
                         this->rc_contexts[context]->rc_prefixes.clear();
                     } else if (sscanf(msg, "cp:%d:%s", &context, type)) {
@@ -1083,7 +1083,7 @@ readline_curses::line_ready(const char* line)
 }
 
 void
-readline_curses::check_poll_set(const vector<struct pollfd>& pollfds)
+readline_curses::check_poll_set(const std::vector<struct pollfd>& pollfds)
 {
     int rc;
 
@@ -1106,7 +1106,7 @@ readline_curses::check_poll_set(const vector<struct pollfd>& pollfds)
         rc = recvstring(
             this->rc_command_pipe[RCF_MASTER], msg, sizeof(msg) - 1);
         if (rc >= 0) {
-            string old_value = this->rc_value;
+            std::string old_value = this->rc_value;
 
             msg[rc] = '\0';
             if (this->rc_matches_remaining > 0) {
@@ -1148,7 +1148,7 @@ readline_curses::check_poll_set(const vector<struct pollfd>& pollfds)
                     case 't':
                     case 'd':
                     case 'D':
-                        this->rc_value = string(&msg[2]);
+                        this->rc_value = std::string(&msg[2]);
                         break;
                 }
                 switch (msg[0]) {
@@ -1273,8 +1273,8 @@ readline_curses::abort()
 
 void
 readline_curses::add_prefix(int context,
-                            const vector<string>& prefix,
+                            const std::vector<std::string>& prefix,
-                            const string& value)
+                            const std::string& value)
 {
     char buffer[1024];
     auto prefix_wire = fmt::format(FMT_STRING("{}"), fmt::join(prefix, "\x1f"));
@@ -1309,8 +1309,8 @@ readline_curses::clear_prefixes(int context)
 
 void
 readline_curses::add_possibility(int context,
-                                 const string& type,
+                                 const std::string& type,
-                                 const string& value)
+                                 const std::string& value)
 {
     char buffer[1024];
 
@@ -1334,8 +1334,8 @@ readline_curses::add_possibility(int context,
 
 void
 readline_curses::rem_possibility(int context,
-                                 const string& type,
+                                 const std::string& type,
-                                 const string& value)
+                                 const std::string& value)
 {
     char buffer[1024];
 
@@ -1354,7 +1354,7 @@ readline_curses::rem_possibility(int context,
 }
 
 void
-readline_curses::clear_possibilities(int context, string type)
+readline_curses::clear_possibilities(int context, std::string type)
 {
     char buffer[1024];
 
@@ -1432,9 +1432,9 @@ readline_curses::do_update()
 std::string
 readline_curses::get_match_string() const
 {
-    auto len = ::min((size_t) this->vc_x, this->rc_line_buffer.size())
+    auto len = std::min((size_t) this->vc_x, this->rc_line_buffer.size())
         - this->rc_match_start;
-    auto context = this->get_active_context();
+    auto* context = this->get_active_context();
 
     if (context->get_append_character() != 0) {
         if (this->rc_line_buffer.length() > (this->rc_match_start + len - 1)

src/readline_curses.hh

@@ -52,7 +52,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/func_util.hh"
 #include "base/result.h"
 #include "help_text_formatter.hh"

src/readline_highlighters.cc

@@ -38,12 +38,10 @@
 #include "sql_help.hh"
 #include "sql_util.hh"
 
-using namespace std;
-
 static void readline_sqlite_highlighter_int(attr_line_t& al, int x, int skip);
 
 static bool
-check_re_prev(const string& line, int x)
+check_re_prev(const std::string& line, int x)
 {
     bool retval = false;
 
@@ -58,7 +56,7 @@ check_re_prev(const string& line, int x)
 }
 
 static bool
-is_bracket(const string& str, int index, bool is_lit)
+is_bracket(const std::string& str, int index, bool is_lit)
 {
     if (is_lit && str[index - 1] == '\\') {
         return true;
@@ -78,7 +76,7 @@ find_matching_bracket(attr_line_t& al, int x, char left, char right)
     int missing_bracket_attrs
         = A_BOLD | A_REVERSE | vc.attrs_for_role(view_colors::VCR_ERROR);
     bool is_lit = (left == 'Q');
-    const string& line = al.get_string();
+    const std::string& line = al.get_string();
     int depth = 0;
 
     if (x < 0 || x > (int) line.length()) {
@@ -150,7 +148,7 @@ find_matching_bracket(attr_line_t& al, int x, char left, char right)
 }
 
 static char
-safe_read(const string& str, string::size_type index)
+safe_read(const std::string& str, std::string::size_type index)
 {
     if (index < str.length()) {
         return str.at(index);
@@ -178,7 +176,7 @@ readline_regex_highlighter_int(attr_line_t& al, int x, int skip)
 
                                      nullptr};
 
-    string& line = al.get_string();
+    auto& line = al.get_string();
     bool backslash_is_quoted = false;
 
     for (size_t lpc = skip; lpc < line.length(); lpc++) {
@@ -345,14 +343,14 @@ readline_command_highlighter(attr_line_t& al, int x)
     view_colors& vc = view_colors::singleton();
     int keyword_attrs = (A_BOLD | vc.attrs_for_role(view_colors::VCR_KEYWORD));
 
-    const string& line = al.get_string();
+    const auto& line = al.get_string();
     pcre_context_static<30> pc;
     pcre_input pi(line);
     size_t ws_index;
 
     ws_index = line.find(' ');
-    string command = line.substr(0, ws_index);
+    auto command = line.substr(0, ws_index);
-    if (ws_index != string::npos) {
+    if (ws_index != std::string::npos) {
         al.get_attrs().emplace_back(
             line_range(1, ws_index), &view_curses::VC_STYLE, keyword_attrs);
     }
@@ -372,7 +370,7 @@ readline_command_highlighter(attr_line_t& al, int x)
         pi.reset(line);
         if (COLOR_RE.match(pc, pi)) {
             pcre_context::capture_t* cap = pc[0];
-            string hash_color = pi.get_substr(cap);
+            auto hash_color = pi.get_substr(cap);
 
             styling::color_unit::from_str(hash_color)
                 .then([&](const auto& rgb_fg) {
@@ -384,7 +382,7 @@ readline_command_highlighter(attr_line_t& al, int x)
         }
     }
     pi.reset(line);
-    if (IDENT_PREFIXES.match(pc, pi) && ws_index != string::npos) {
+    if (IDENT_PREFIXES.match(pc, pi) && ws_index != std::string::npos) {
         size_t start = ws_index, last;
 
         do {
@@ -398,7 +396,7 @@ readline_command_highlighter(attr_line_t& al, int x)
             };
 
             if (lr.length() > 0 && !lr.contains(x) && !lr.contains(x - 1)) {
-                string value(lr.substr(line), lr.sublen(line));
+                std::string value(lr.substr(line), lr.sublen(line));
 
                 if ((command == ":tag" || command == ":untag"
                      || command == ":delete-tags")
@@ -418,7 +416,7 @@ readline_command_highlighter(attr_line_t& al, int x)
 static void
 readline_sqlite_highlighter_int(attr_line_t& al, int x, int skip)
 {
-    static string keyword_re_str = sql_keyword_re();
+    static const auto keyword_re_str = sql_keyword_re();
     static pcrepp keyword_pcre(keyword_re_str.c_str(), PCRE_CASELESS);
     static pcrepp string_literal_pcre("'[^']*('(?:'[^']*')*|$)");
     static pcrepp ident_pcre(
@@ -526,7 +524,7 @@ readline_shlex_highlighter(attr_line_t& al, int x)
     int special_char = (A_BOLD | vc.attrs_for_role(view_colors::VCR_SYMBOL));
     int error_attrs = vc.attrs_for_role(view_colors::VCR_ERROR) | A_REVERSE;
     int string_attrs = vc.attrs_for_role(view_colors::VCR_STRING);
-    const string& str = al.get_string();
+    const auto& str = al.get_string();
     pcre_context::capture_t cap;
     shlex_token_t token;
     int quote_start = -1;
@@ -559,8 +557,8 @@ readline_shlex_highlighter(attr_line_t& al, int x)
             case shlex_token_t::ST_VARIABLE_REF:
             case shlex_token_t::ST_QUOTED_VARIABLE_REF: {
                 int extra = token == shlex_token_t::ST_VARIABLE_REF ? 0 : 1;
-                string ident = str.substr(cap.c_begin + 1 + extra,
+                auto ident = str.substr(cap.c_begin + 1 + extra,
-                                          cap.length() - 1 - extra * 2);
+                                        cap.length() - 1 - extra * 2);
                 int attrs = vc.attrs_for_ident(ident);
 
                 al.with_attr(string_attr(

src/readline_possibilities.cc

@@ -47,8 +47,6 @@
 #include "tailer/tailer.looper.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
-
 static int
 handle_collation_list(void* ptr, int ncols, char** colvalues, char** colnames)
 {
@@ -73,7 +71,7 @@ static int
 handle_table_list(void* ptr, int ncols, char** colvalues, char** colnames)
 {
     if (lnav_data.ld_rl_view != nullptr) {
-        string table_name = colvalues[0];
+        std::string table_name = colvalues[0];
 
         if (sqlite_function_help.count(table_name) == 0) {
             lnav_data.ld_rl_view->add_possibility(LNM_SQL, "*", colvalues[0]);
@@ -93,7 +91,7 @@ handle_table_info(void* ptr, int ncols, char** colvalues, char** colnames)
 
         quoted_name = sql_quote_ident(colvalues[1]);
         lnav_data.ld_rl_view->add_possibility(
-            LNM_SQL, "*", string(quoted_name));
+            LNM_SQL, "*", std::string(quoted_name));
     }
     if (strcmp(colvalues[5], "1") == 0) {
         lnav_data.ld_db_key_names.emplace_back(colvalues[1]);
@@ -120,7 +118,7 @@ struct sqlite_metadata_callbacks lnav_sql_meta_callbacks = {
 static void
 add_text_possibilities(readline_curses* rlc,
                        int context,
-                       const string& type,
+                       const std::string& type,
                        const std::string& str)
 {
     static const std::regex re_escape(R"(([.\^$*+?()\[\]{}\\|]))");
@@ -146,7 +144,7 @@ add_text_possibilities(readline_curses* rlc,
 
         switch (context) {
             case LNM_SQL: {
-                string token_value = ds.get_input().get_substr(pc.all());
+                auto token_value = ds.get_input().get_substr(pc.all());
                 auto_mem<char, sqlite3_free> quoted_token;
 
                 quoted_token = sqlite3_mprintf("%Q", token_value.c_str());
@@ -154,7 +152,7 @@ add_text_possibilities(readline_curses* rlc,
                 break;
             }
             default: {
-                string token_value, token_value_no_dot;
+                std::string token_value, token_value_no_dot;
 
                 token_value_no_dot = token_value
                     = ds.get_input().get_substr(pc.all());
@@ -184,7 +182,7 @@ add_text_possibilities(readline_curses* rlc,
 void
 add_view_text_possibilities(readline_curses* rlc,
                             int context,
-                            const string& type,
+                            const std::string& type,
                             textview_curses* tc)
 {
     text_sub_source* tss = tc->get_sub_source();
@@ -194,7 +192,7 @@ add_view_text_possibilities(readline_curses* rlc,
     for (vis_line_t curr_line = tc->get_top(); curr_line <= tc->get_bottom();
          ++curr_line)
     {
-        string line;
+        std::string line;
 
         tss->text_value_for_line(*tc, curr_line, line, text_sub_source::RF_RAW);
 
@@ -241,7 +239,7 @@ add_filter_expr_possibilities(readline_curses* rlc,
         auto format = lf->get_format();
         shared_buffer_ref sbr;
         string_attrs_t sa;
-        vector<logline_value> values;
+        std::vector<logline_value> values;
 
         lf->read_full_message(ll, sbr);
         format->annotate(cl, sbr, sa, values);
@@ -269,7 +267,7 @@ add_filter_expr_possibilities(readline_curses* rlc,
 
                     str = sqlite3_mprintf(
                         "%.*Q", lv.text_length(), lv.text_value());
-                    rlc->add_possibility(context, type, string(str.in()));
+                    rlc->add_possibility(context, type, std::string(str.in()));
                     break;
                 }
             }
@@ -289,7 +287,7 @@ add_filter_expr_possibilities(readline_curses* rlc,
             rlc->add_possibility(
                 context,
                 type,
-                string(func_def.zName) + (func_def.nArg ? "(" : "()"));
+                std::string(func_def.zName) + (func_def.nArg ? "(" : "()"));
         }
         for (int lpc2 = 0; agg_funcs && agg_funcs[lpc2].zName; lpc2++) {
             const FuncDefAgg& func_def = agg_funcs[lpc2];
@@ -297,7 +295,7 @@ add_filter_expr_possibilities(readline_curses* rlc,
             rlc->add_possibility(
                 context,
                 type,
-                string(func_def.zName) + (func_def.nArg ? "(" : "()"));
+                std::string(func_def.zName) + (func_def.nArg ? "(" : "()"));
         }
     }
 }
@@ -310,7 +308,7 @@ add_env_possibilities(int context)
 
     for (char** var = environ; *var != nullptr; var++) {
         rlc->add_possibility(
-            context, "*", "$" + string(*var, strchr(*var, '=')));
+            context, "*", "$" + std::string(*var, strchr(*var, '=')));
     }
 
     exec_context& ec = lnav_data.ld_exec_context;
@@ -400,9 +398,9 @@ void
 add_config_possibilities()
 {
     readline_curses* rc = lnav_data.ld_rl_view;
-    set<string> visited;
+    std::set<std::string> visited;
     auto cb = [rc, &visited](const json_path_handler_base& jph,
-                             const string& path,
+                             const std::string& path,
                              void* mem) {
         if (jph.jph_children) {
             if (!jph.jph_regex.p_named_count) {
@@ -423,14 +421,14 @@ add_config_possibilities()
             rc->add_possibility(LNM_COMMAND, "config-option", path);
             if (jph.jph_synopsis) {
                 rc->add_prefix(LNM_COMMAND,
-                               vector<string>{"config", path},
+                               std::vector<std::string>{"config", path},
                                jph.jph_synopsis);
             }
         }
     };
 
     rc->clear_possibilities(LNM_COMMAND, "config-option");
-    for (auto& jph : lnav_config_handlers.jpc_children) {
+    for (const auto& jph : lnav_config_handlers.jpc_children) {
         jph.walk(cb, &lnav_config);
     }
 }
@@ -449,8 +447,7 @@ add_tag_possibilities()
         logfile_sub_source& lss = lnav_data.ld_log_source;
         if (lss.text_line_count() > 0) {
             content_line_t cl = lss.at(lnav_data.ld_views[LNV_LOG].get_top());
-            const map<content_line_t, bookmark_metadata>& user_meta
+            const auto& user_meta = lss.get_user_bookmark_metadata();
-                = lss.get_user_bookmark_metadata();
             auto meta_iter = user_meta.find(cl);
 
             if (meta_iter != user_meta.end()) {

src/regexp_vtab.cc

@@ -34,8 +34,6 @@
 #include "sql_util.hh"
 #include "vtab_module.hh"
 
-using namespace std;
-
 enum {
     RC_COL_MATCH_INDEX,
     RC_COL_INDEX,
@@ -70,8 +68,8 @@ CREATE TABLE regexp_capture (
         sqlite3_vtab_cursor base;
         pcrepp c_pattern;
         pcre_context_static<30> c_context;
-        unique_ptr<pcre_input> c_input;
+        std::unique_ptr<pcre_input> c_input;
-        string c_content;
+        std::string c_content;
         bool c_content_as_blob{false};
         int c_index;
         int c_start_index;
@@ -247,7 +245,7 @@ rcFilter(sqlite3_vtab_cursor* pVtabCursor,
     pCur->c_index = 0;
     pCur->c_context.set_count(0);
 
-    pCur->c_input = make_unique<pcre_input>(pCur->c_content);
+    pCur->c_input = std::make_unique<pcre_input>(pCur->c_content);
     pCur->c_matched = pCur->c_pattern.match(pCur->c_context, *(pCur->c_input));
 
     log_debug("matched %d", pCur->c_matched);
@@ -272,10 +270,11 @@ register_regexp_vtab(sqlite3* db)
               .with_parameter(
                   {"string", "The string to match against the given pattern."})
               .with_parameter({"pattern", "The regular expression to match."})
-              .with_result(
+              .with_result({
-                  {"match_index",
+                  "match_index",
-                   "The match iteration.  This value will increase "
+                  "The match iteration.  This value will increase "
-                   "each time a new match is found in the input string."})
+                  "each time a new match is found in the input string.",
+              })
               .with_result(
                   {"capture_index", "The index of the capture in the regex."})
               .with_result(
@@ -288,10 +287,12 @@ register_regexp_vtab(sqlite3* db)
                             "The stop of the capture in the input string."})
               .with_result({"content", "The captured value from the string."})
               .with_tags({"string"})
-              .with_example({"To extract the key/value pairs 'a'/1 and 'b'/2 "
+              .with_example({
-                             "from the string 'a=1; b=2'",
+                  "To extract the key/value pairs 'a'/1 and 'b'/2 "
-                             "SELECT * FROM regexp_capture('a=1; b=2', "
+                  "from the string 'a=1; b=2'",
-                             "'(\\w+)=(\\d+)')"});
+                  "SELECT * FROM regexp_capture('a=1; b=2', "
+                  "'(\\w+)=(\\d+)')",
+              });
 
     int rc;
 
@@ -300,7 +301,7 @@ register_regexp_vtab(sqlite3* db)
 
     rc = REGEXP_CAPTURE_MODULE.create(db, "regexp_capture");
     sqlite_function_help.insert(
-        make_pair("regexp_capture", &regexp_capture_help));
+        std::make_pair("regexp_capture", &regexp_capture_help));
     regexp_capture_help.index_tags();
 
     ensure(rc == SQLITE_OK);

src/relative_time.cc

@@ -35,7 +35,6 @@
 #include "config.h"
 #include "pcrepp/pcrepp.hh"
 
-using namespace std;
 using namespace std::chrono_literals;
 
 static const struct {
@@ -333,15 +332,15 @@ relative_time::from_str(const char* str, size_t len)
                 case RTT_AT:
                     break;
                 case RTT_TIME: {
-                    string hstr = pi.get_substr(pc[0]);
+                    const auto hstr = pi.get_substr(pc[0]);
-                    string mstr = pi.get_substr(pc[1]);
+                    const auto mstr = pi.get_substr(pc[1]);
                     retval.rt_field[RTF_HOURS] = atoi(hstr.c_str());
                     retval.rt_field[RTF_MINUTES] = atoi(mstr.c_str());
                     if (pc[2]->is_valid()) {
-                        string sstr = pi.get_substr(pc[2]);
+                        const auto sstr = pi.get_substr(pc[2]);
                         retval.rt_field[RTF_SECONDS] = atoi(sstr.c_str());
                         if (pc[3]->is_valid()) {
-                            string substr = pi.get_substr(pc[3]);
+                            const auto substr = pi.get_substr(pc[3]);
 
                             switch (substr.length()) {
                                 case 3:
@@ -372,7 +371,7 @@ relative_time::from_str(const char* str, size_t len)
                         return Err(pe_out);
                     }
 
-                    string numstr = pi.get_substr(pc[0]);
+                    const auto numstr = pi.get_substr(pc[0]);
 
                     if (sscanf(numstr.c_str(), "%" PRId64, &number) != 1) {
                         pe_out.pe_msg = "Invalid number: " + numstr;

src/sequence_matcher.cc

@@ -32,8 +32,6 @@
 #include "config.h"
 #include "spookyhash/SpookyV2.h"
 
-using namespace std;
-
 sequence_matcher::sequence_matcher(field_col_t& example)
 {
     for (field_col_t::iterator col_iter = example.begin();
@@ -63,7 +61,7 @@ sequence_matcher::sequence_matcher(field_col_t& example)
 }
 
 void
-sequence_matcher::identity(const std::vector<string>& values, id_t& id_out)
+sequence_matcher::identity(const std::vector<std::string>& values, id_t& id_out)
 {
     SpookyHash context;
     int lpc = 0;

src/session_data.cc

@@ -56,8 +56,6 @@
 #include "yajlpp/yajlpp.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
-
 struct session_data_t session_data;
 
 static const char* LOG_METADATA_NAME = "log_metadata.db";
@@ -142,7 +140,7 @@ bind_to_sqlite(sqlite3_stmt* stmt, int index, intern_string_t ist)
 }
 
 int
-bind_to_sqlite(sqlite3_stmt* stmt, int index, const string& str)
+bind_to_sqlite(sqlite3_stmt* stmt, int index, const std::string& str)
 {
     return sqlite3_bind_text(
         stmt, index, str.c_str(), str.size(), SQLITE_TRANSIENT);
@@ -189,9 +187,7 @@ bind_line(sqlite3* db,
           time_t session_time)
 {
     logfile_sub_source& lss = lnav_data.ld_log_source;
-    shared_ptr<logfile> lf;
+    auto lf = lss.find(cl);
-
-    lf = lss.find(cl);
 
     if (lf == nullptr) {
         return false;
@@ -224,7 +220,7 @@ bind_line(sqlite3* db,
 }
 
 struct session_file_info {
-    session_file_info(int timestamp, string id, string path)
+    session_file_info(int timestamp, std::string id, std::string path)
         : sfi_timestamp(timestamp), sfi_id(std::move(id)),
           sfi_path(std::move(path)){};
 
@@ -240,8 +236,8 @@ struct session_file_info {
     };
 
     int sfi_timestamp;
-    string sfi_id;
+    std::string sfi_id;
-    string sfi_path;
+    std::string sfi_path;
 };
 
 static void
@@ -249,7 +245,7 @@ cleanup_session_data()
 {
     static_root_mem<glob_t, globfree> session_file_list;
     std::list<struct session_file_info> session_info_list;
-    map<string, int> session_count;
+    std::map<std::string, int> session_count;
     auto session_file_pattern = lnav::paths::dotlnav() / "*-*.ts*.json";
 
     if (glob(
@@ -492,7 +488,7 @@ load_time_bookmarks()
          file_iter != lnav_data.ld_log_source.end();
          ++file_iter)
     {
-        shared_ptr<logfile> lf = (*file_iter)->get_file();
+        auto lf = (*file_iter)->get_file();
         content_line_t base_content_line;
 
         if (lf == nullptr) {
@@ -518,7 +514,7 @@ load_time_bookmarks()
 
         date_time_scanner dts;
         bool done = false;
-        string line;
+        std::string line;
         int64_t last_mark_time = -1;
 
         while (!done) {
@@ -582,7 +578,7 @@ load_time_bookmarks()
 
                         auto sbr = read_result.unwrap();
 
-                        string line_hash
+                        auto line_hash
                             = hasher()
                                   .update(sbr.get_data(), sbr.length())
                                   .update(cl)
@@ -681,7 +677,7 @@ load_time_bookmarks()
          file_iter != lnav_data.ld_log_source.end();
          ++file_iter)
     {
-        shared_ptr<logfile> lf = (*file_iter)->get_file();
+        auto lf = (*file_iter)->get_file();
         content_line_t base_content_line;
 
         if (lf == nullptr) {
@@ -707,7 +703,7 @@ load_time_bookmarks()
 
         date_time_scanner dts;
         bool done = false;
-        string line;
+        std::string line;
         int64_t last_mark_time = -1;
 
         while (!done) {
@@ -807,7 +803,7 @@ read_current_search(yajlpp_parse_context* ypc,
                     const unsigned char* str,
                     size_t len)
 {
-    string regex = std::string((const char*) str, len);
+    const auto regex = std::string((const char*) str, len);
     const char** view_name;
     int view_index;
 
@@ -1067,7 +1063,7 @@ save_user_bookmarks(sqlite3* db,
                 return;
             }
 
-            string tags;
+            std::string tags;
 
             if (!line_meta.bm_tags.empty()) {
                 yajlpp_gen gen;
@@ -1226,7 +1222,7 @@ save_time_bookmarks()
              file_iter != lnav_data.ld_log_source.end();
              ++file_iter)
         {
-            shared_ptr<logfile> lf = (*file_iter)->get_file();
+            auto lf = (*file_iter)->get_file();
 
             if (lf == nullptr) {
                 continue;
@@ -1320,7 +1316,7 @@ save_time_bookmarks()
              file_iter != lnav_data.ld_log_source.end();
              ++file_iter)
         {
-            shared_ptr<logfile> lf = (*file_iter)->get_file();
+            auto lf = (*file_iter)->get_file();
             content_line_t base_content_line;
 
             if (lf == nullptr) {
@@ -1366,7 +1362,7 @@ save_time_bookmarks()
         if (ls->get_file() == nullptr)
             continue;
 
-        shared_ptr<logfile> lf = ls->get_file();
+        auto lf = ls->get_file();
 
         if (!lf->is_time_adjusted()) {
             continue;
@@ -1528,7 +1524,7 @@ save_session_with_id(const std::string& session_id)
                     yajlpp_array cmd_array(handle);
 
                     for (const auto& filter : fs) {
-                        string cmd = filter->to_command();
+                        auto cmd = filter->to_command();
 
                         if (cmd.empty()) {
                             continue;
@@ -1582,13 +1578,13 @@ save_session_with_id(const std::string& session_id)
                             min_time_str, sizeof(min_time_str), min_time);
                         if (have_min_time) {
                             cmd_array.gen("hide-lines-before "
-                                          + string(min_time_str));
+                                          + std::string(min_time_str));
                         }
                         if (have_max_time) {
                             sql_strftime(
                                 max_time_str, sizeof(max_time_str), max_time);
                             cmd_array.gen("hide-lines-after "
-                                          + string(max_time_str));
+                                          + std::string(max_time_str));
                         }
 
                         auto mark_expr = lss.get_sql_marker_text();

src/sql_util.cc

@@ -51,8 +51,6 @@
 #include "sql_help.hh"
 #include "sqlite-extension-func.hh"
 
-using namespace std;
-
 /**
  * Copied from -- http://www.sqlite.org/lang_keywords.html
  */
@@ -259,7 +257,7 @@ const char* sql_function_names[] = {
 
     nullptr};
 
-multimap<std::string, help_text*> sqlite_function_help;
+std::multimap<std::string, help_text*> sqlite_function_help;
 
 static int
 handle_db_list(void* ptr, int ncols, char** colvalues, char** colnames)
@@ -394,7 +392,7 @@ static int
 schema_db_list(void* ptr, int ncols, char** colvalues, char** colnames)
 {
     struct sqlite_metadata_callbacks* smc = (sqlite_metadata_callbacks*) ptr;
-    string& schema_out = *((string*) smc->smc_userdata);
+    std::string& schema_out = *((std::string*) smc->smc_userdata);
     auto_mem<char, sqlite3_free> attach_sql;
 
     attach_sql = sqlite3_mprintf(
@@ -409,7 +407,7 @@ static int
 schema_table_list(void* ptr, int ncols, char** colvalues, char** colnames)
 {
     struct sqlite_metadata_callbacks* smc = (sqlite_metadata_callbacks*) ptr;
-    string& schema_out = *((string*) smc->smc_userdata);
+    std::string& schema_out = *((std::string*) smc->smc_userdata);
     auto_mem<char, sqlite3_free> create_sql;
 
     create_sql = sqlite3_mprintf("%s;\n", colvalues[1]);
@@ -471,9 +469,9 @@ attach_sqlite_db(sqlite3* db, const std::string& filename)
     }
 
     size_t base_start = filename.find_last_of("/\\");
-    string db_name;
+    std::string db_name;
 
-    if (base_start == string::npos) {
+    if (base_start == std::string::npos) {
         db_name = filename;
     } else {
         db_name = filename.substr(base_start + 1);
@@ -634,10 +632,10 @@ sql_quote_ident(const char* ident)
     return retval;
 }
 
-string
+std::string
 sql_safe_ident(const string_fragment& ident)
 {
-    string retval = to_string(ident);
+    std::string retval = std::to_string(ident);
 
     for (size_t lpc = 0; lpc < retval.size(); lpc++) {
         char ch = retval[lpc];
@@ -710,7 +708,7 @@ sql_execute_script(sqlite3* db,
                    const std::vector<sqlite3_stmt*>& stmts,
                    std::vector<std::string>& errors)
 {
-    map<string, string> lvars;
+    std::map<std::string, std::string> lvars;
 
     for (sqlite3_stmt* stmt : stmts) {
         bool done = false;
@@ -724,7 +722,7 @@ sql_execute_script(sqlite3* db,
 
             name = sqlite3_bind_parameter_name(stmt, lpc + 1);
             if (name[0] == '$') {
-                map<string, string>::iterator iter;
+                std::map<std::string, std::string>::iterator iter;
                 const char* env_value;
 
                 if ((iter = lvars.find(&name[1])) != lvars.end()) {
@@ -784,7 +782,7 @@ sql_execute_script(sqlite3* db,
                    const char* script,
                    std::vector<std::string>& errors)
 {
-    vector<sqlite3_stmt*> stmts;
+    std::vector<sqlite3_stmt*> stmts;
 
     sql_compile_script(db, src_name, script, stmts, errors);
     if (errors.empty()) {
@@ -808,11 +806,11 @@ static struct {
 };
 
 int
-guess_type_from_pcre(const string& pattern, std::string& collator)
+guess_type_from_pcre(const std::string& pattern, std::string& collator)
 {
     try {
         pcrepp re(pattern);
-        vector<int> matches;
+        std::vector<int> matches;
         int retval = SQLITE3_TEXT;
         int index = 0;
 
@@ -862,10 +860,10 @@ sqlite_authorizer(void* pUserData,
     return SQLITE_OK;
 }
 
-string
+std::string
 sql_keyword_re()
 {
-    string retval = "(?:";
+    std::string retval = "(?:";
     bool first = true;
 
     for (const char* kw : sql_keywords) {
@@ -896,7 +894,7 @@ string_attr_type SQL_GARBAGE_ATTR("sql_garbage");
 void
 annotate_sql_statement(attr_line_t& al)
 {
-    static string keyword_re_str = R"(\A)" + sql_keyword_re();
+    static const std::string keyword_re_str = R"(\A)" + sql_keyword_re();
 
     static struct {
         pcrepp re;
@@ -986,12 +984,12 @@ annotate_sql_statement(attr_line_t& al)
     stable_sort(sa.begin(), sa.end());
 }
 
-vector<const help_text*>
+std::vector<const help_text*>
 find_sql_help_for_line(const attr_line_t& al, size_t x)
 {
-    vector<const help_text*> retval;
+    std::vector<const help_text*> retval;
     const auto& sa = al.get_attrs();
-    string name;
+    std::string name;
 
     x = al.nearest_text(x);
 
@@ -999,8 +997,8 @@ find_sql_help_for_line(const attr_line_t& al, size_t x)
         auto sa_opt = get_string_attr(al.get_attrs(), &SQL_COMMAND_ATTR);
 
         if (sa_opt) {
-            auto sql_cmd_map = injector::get<readline_context::command_map_t*,
+            auto* sql_cmd_map = injector::get<readline_context::command_map_t*,
-                                             sql_cmd_map_tag>();
+                                              sql_cmd_map_tag>();
             auto cmd_name = al.get_substring((*sa_opt)->sa_range);
             auto cmd_iter = sql_cmd_map->find(cmd_name);
 
@@ -1010,14 +1008,14 @@ find_sql_help_for_line(const attr_line_t& al, size_t x)
         }
     }
 
-    vector<string> kw;
+    std::vector<std::string> kw;
     auto iter = rfind_string_attr_if(sa, x, [&al, &name, &kw, x](auto sa) {
         if (sa.sa_type != &SQL_FUNCTION_ATTR && sa.sa_type != &SQL_KEYWORD_ATTR)
         {
             return false;
         }
 
-        const string& str = al.get_string();
+        const std::string& str = al.get_string();
         const line_range& lr = sa.sa_range;
         int lpc;
 
@@ -1033,7 +1031,7 @@ find_sql_help_for_line(const attr_line_t& al, size_t x)
             }
         }
 
-        string tmp_name = str.substr(lr.lr_start, lpc - lr.lr_start);
+        auto tmp_name = str.substr(lr.lr_start, lpc - lr.lr_start);
         if (sa.sa_type == &SQL_KEYWORD_ATTR) {
             tmp_name = toupper(tmp_name);
         }
@@ -1048,7 +1046,7 @@ find_sql_help_for_line(const attr_line_t& al, size_t x)
 
     if (iter != sa.end()) {
         auto func_pair = sqlite_function_help.equal_range(name);
-        size_t help_count = distance(func_pair.first, func_pair.second);
+        size_t help_count = std::distance(func_pair.first, func_pair.second);
 
         if (help_count > 1 && name != func_pair.first->second->ht_name) {
             while (func_pair.first != func_pair.second) {

src/sqlite-extension-func.cc

@@ -37,8 +37,6 @@
 #include "config.h"
 #include "sql_help.hh"
 
-using namespace std;
-
 extern "C" {
 struct sqlite3_api_routines;
 
@@ -96,7 +94,7 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             if (fd.fd_help.ht_context != help_context_t::HC_NONE) {
                 help_text& ht = fd.fd_help;
 
-                sqlite_function_help.insert(make_pair(ht.ht_name, &ht));
+                sqlite_function_help.insert(std::make_pair(ht.ht_name, &ht));
                 ht.index_tags();
             }
         }
@@ -117,7 +115,7 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             if (fda.fda_help.ht_context != help_context_t::HC_NONE) {
                 help_text& ht = fda.fda_help;
 
-                sqlite_function_help.insert(make_pair(ht.ht_name, &ht));
+                sqlite_function_help.insert(std::make_pair(ht.ht_name, &ht));
                 ht.index_tags();
             }
         }
@@ -696,9 +694,11 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             .sql_function()
             .with_parameter({"X", "The values to add."})
             .with_tags({"math"})
-            .with_example({"To sum all of the values in the column "
+            .with_example({
-                           "'ex_duration' from the table 'lnav_example_log'",
+                "To sum all of the values in the column "
-                           "SELECT sum(ex_duration) FROM lnav_example_log"}),
+                "'ex_duration' from the table 'lnav_example_log'",
+                "SELECT sum(ex_duration) FROM lnav_example_log",
+            }),
 
         help_text(
             "total",
@@ -706,9 +706,11 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             .sql_function()
             .with_parameter({"X", "The values to add."})
             .with_tags({"math"})
-            .with_example({"To total all of the values in the column "
+            .with_example({
-                           "'ex_duration' from the table 'lnav_example_log'",
+                "To total all of the values in the column "
-                           "SELECT total(ex_duration) FROM lnav_example_log"}),
+                "'ex_duration' from the table 'lnav_example_log'",
+                "SELECT total(ex_duration) FROM lnav_example_log",
+            }),
 
         help_text("generate_series",
                   "A table-valued-function that returns the whole numbers "
@@ -720,16 +722,19 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
                 help_text("step", "The increment between each value")
                     .optional())
             .with_result({"value", "The number in the series"})
-            .with_example({"To generate the numbers in the range [10, 14]",
+            .with_example({
-                           "SELECT value FROM generate_series(10, 14)"})
+                "To generate the numbers in the range [10, 14]",
-            .with_example(
+                "SELECT value FROM generate_series(10, 14)",
-                {"To generate every other number in the range [10, 14]",
+            })
-                 "SELECT value FROM generate_series(10, 14, 2)"})
+            .with_example({
+                "To generate every other number in the range [10, 14]",
+                "SELECT value FROM generate_series(10, 14, 2)",
+            })
             .with_example({"To count down from five to 1",
                            "SELECT value FROM generate_series(1, 5, -1)"})};
 
     for (auto& ht : builtin_funcs) {
-        sqlite_function_help.insert(make_pair(ht.ht_name, &ht));
+        sqlite_function_help.insert(std::make_pair(ht.ht_name, &ht));
         ht.index_tags();
     }
 
@@ -830,7 +835,7 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
     };
 
     for (auto& ht : builtin_win_funcs) {
-        sqlite_function_help.insert(make_pair(ht.ht_name, &ht));
+        sqlite_function_help.insert(std::make_pair(ht.ht_name, &ht));
         ht.index_tags();
     }
 
@@ -995,9 +1000,10 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
                                       "a row should be updated.")
                                 .with_flag_name("WHERE")
                                 .optional())
-            .with_example(
+            .with_example({
-                {"To mark the syslog message at line 40",
+                "To mark the syslog message at line 40",
-                 "UPDATE syslog_log SET log_mark = 1 WHERE log_line = 40"}),
+                "UPDATE syslog_log SET log_mark = 1 WHERE log_line = 40",
+            }),
 
         help_text("CASE",
                   "Evaluate a series of expressions in order until one "
@@ -1023,9 +1029,10 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
                     .with_flag_name("ELSE")
                     .optional())
             .with_parameter(help_text("").with_flag_name("END"))
-            .with_example(
+            .with_example({
-                {"To evaluate the number one and return the string 'one'",
+                "To evaluate the number one and return the string 'one'",
-                 "SELECT CASE 1 WHEN 0 THEN 'zero' WHEN 1 THEN 'one' END"}),
+                "SELECT CASE 1 WHEN 0 THEN 'zero' WHEN 1 THEN 'one' END",
+            }),
 
         help_text("CAST",
                   "Convert the value of the given expression to a different "
@@ -1035,8 +1042,10 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             .with_parameter(
                 help_text("type-name", "The name of the type to convert to.")
                     .with_flag_name("AS"))
-            .with_example({"To cast the value 1.23 as an integer",
+            .with_example({
-                           "SELECT CAST(1.23 AS INTEGER)"}),
+                "To cast the value 1.23 as an integer",
+                "SELECT CAST(1.23 AS INTEGER)",
+            }),
 
         help_text("expr", "Match an expression against a glob pattern.")
             .sql_infix()
@@ -1044,8 +1053,10 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             .with_parameter(
                 help_text("pattern", "The glob pattern to match against.")
                     .with_flag_name("GLOB"))
-            .with_example({"To check if a value matches the pattern '*.log'",
+            .with_example({
-                           "SELECT 'foobar.log' GLOB '*.log'"}),
+                "To check if a value matches the pattern '*.log'",
+                "SELECT 'foobar.log' GLOB '*.log'",
+            }),
 
         help_text("expr", "Match an expression against a text pattern.")
             .sql_infix()
@@ -1053,9 +1064,10 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             .with_parameter(
                 help_text("pattern", "The pattern to match against.")
                     .with_flag_name("LIKE"))
-            .with_example(
+            .with_example({
-                {"To check if a value matches the pattern 'Hello, %!'",
+                "To check if a value matches the pattern 'Hello, %!'",
-                 "SELECT 'Hello, World!' LIKE 'Hello, %!'"}),
+                "SELECT 'Hello, World!' LIKE 'Hello, %!'",
+            }),
 
         help_text("expr", "Match an expression against a regular expression.")
             .sql_infix()
@@ -1063,19 +1075,21 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
             .with_parameter(
                 help_text("pattern", "The regular expression to match against.")
                     .with_flag_name("REGEXP"))
-            .with_example(
+            .with_example({
-                {"To check if a value matches the pattern 'file-\\d+'",
+                "To check if a value matches the pattern 'file-\\d+'",
-                 "SELECT 'file-23' REGEXP 'file-\\d+'"}),
+                "SELECT 'file-23' REGEXP 'file-\\d+'",
+            }),
 
         help_text("expr", "Assign a collating sequence to the expression.")
             .sql_infix()
             .with_parameter(
                 help_text("collation-name", "The name of the collator.")
                     .with_flag_name("COLLATE"))
-            .with_example(
+            .with_example({
-                {"To change the collation method for string comparisons",
+                "To change the collation method for string comparisons",
-                 "SELECT ('a2' < 'a10'), ('a2' < 'a10' COLLATE "
+                "SELECT ('a2' < 'a10'), ('a2' < 'a10' COLLATE "
-                 "naturalnocase)"}),
+                "naturalnocase)",
+            }),
 
         help_text("expr", "Test if an expression is between two values.")
             .sql_infix()
@@ -1084,10 +1098,14 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
                 help_text("low", "The low point").with_flag_name("BETWEEN"))
             .with_parameter(
                 help_text("hi", "The high point").with_flag_name("AND"))
-            .with_example({"To check if 3 is between 5 and 10",
+            .with_example({
-                           "SELECT 3 BETWEEN 5 AND 10"})
+                "To check if 3 is between 5 and 10",
-            .with_example({"To check if 10 is between 5 and 10",
+                "SELECT 3 BETWEEN 5 AND 10",
-                           "SELECT 10 BETWEEN 5 AND 10"}),
+            })
+            .with_example({
+                "To check if 10 is between 5 and 10",
+                "SELECT 10 BETWEEN 5 AND 10",
+            }),
 
         help_text("OVER", "Executes the preceding function over a window")
             .sql_keyword()
@@ -1096,8 +1114,10 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
 
         help_text("OVER", "Executes the preceding function over a window")
             .sql_function()
-            .with_parameter(help_text{"base-window-name",
+            .with_parameter(help_text{
-                                      "The name of the window definition"}
+                "base-window-name",
+                "The name of the window definition",
+            }
                                 .optional())
             .with_parameter(
                 help_text{"expr", "The values to use for partitioning"}
@@ -1107,9 +1127,11 @@ register_sqlite_funcs(sqlite3* db, sqlite_registration_func_t* reg_funcs)
                 "expr", "The values used to order the rows in the window"}
                                 .with_flag_name("ORDER BY")
                                 .zero_or_more())
-            .with_parameter(help_text{"frame-spec",
+            .with_parameter(help_text{
-                                      "Determines which output rows are read "
+                "frame-spec",
-                                      "by an aggregate window function"}
+                "Determines which output rows are read "
+                "by an aggregate window function",
+            }
                                 .optional()),
     };
 

src/statusview_curses.cc

@@ -36,8 +36,6 @@
 
 #include "config.h"
 
-using namespace std;
-
 void
 status_field::set_value(std::string value)
 {
@@ -157,7 +155,7 @@ statusview_curses::do_update()
             }
 
             if (val.length() > sf.get_width()) {
-                static const string ELLIPSIS = "\xE2\x8B\xAF";
+                static const std::string ELLIPSIS = "\xE2\x8B\xAF";
 
                 if (sf.get_width() > 11) {
                     size_t half_width = sf.get_width() / 2 - 1;
@@ -196,7 +194,7 @@ statusview_curses::window_change()
     int total_shares = 0;
     unsigned long width, height;
     double remaining = 0;
-    vector<status_field*> resizable;
+    std::vector<status_field*> resizable;
 
     getmaxyx(this->sc_window, height, width);
     // Silence the compiler. Remove this if height is used at a later stage.
@@ -239,6 +237,4 @@ statusview_curses::window_change()
 
         sf->set_width(actual_width);
     }
-
-    this->sc_last_width = width;
 }

src/statusview_curses.hh

@@ -248,7 +248,6 @@ private:
     status_data_source* sc_source{nullptr};
     WINDOW* sc_window{nullptr};
     int sc_top{0};
-    unsigned long sc_last_width{0};
     bool sc_enabled{true};
 };
 

src/string-extension-functions.cc

@@ -38,27 +38,26 @@
 #include "yajlpp/json_op.hh"
 #include "yajlpp/yajlpp.hh"
 
-using namespace std;
 using namespace mapbox;
 
 typedef struct {
-    shared_ptr<pcrepp> re2;
+    std::shared_ptr<pcrepp> re2;
 } cache_entry;
 
 static cache_entry*
 find_re(const char* re)
 {
-    using safe_cache = safe::Safe<unordered_map<string, cache_entry>>;
+    using safe_cache = safe::Safe<std::unordered_map<std::string, cache_entry>>;
     static safe_cache CACHE;
 
     safe::WriteAccess<safe_cache> wcache(CACHE);
-    string re_str = re;
+    std::string re_str = re;
     auto iter = wcache->find(re_str);
 
     if (iter == wcache->end()) {
         cache_entry c;
 
-        c.re2 = make_shared<pcrepp>(re_str);
+        c.re2 = std::make_shared<pcrepp>(re_str);
         auto pair = wcache->insert(std::make_pair(re_str, c));
 
         iter = pair.first;
@@ -102,33 +101,34 @@ regexp_match(const char* re, const char* str)
 
         if (!cap->is_valid()) {
             return static_cast<const char*>(nullptr);
-        } else {
-            char* cap_copy = (char*) alloca(cap->length() + 1);
-            long long int i_value;
-            double d_value;
-            int end_index;
-
-            memcpy(cap_copy, cap_start, cap->length());
-            cap_copy[cap->length()] = '\0';
-
-            if (sscanf(cap_copy, "%lld%n", &i_value, &end_index) == 1
-                && (end_index == cap->length()))
-            {
-                return (int64_t) i_value;
-            } else if (sscanf(cap_copy, "%lf%n", &d_value, &end_index) == 1
-                       && (end_index == cap->length()))
-            {
-                return d_value;
-            } else {
-                return string_fragment(str, cap->c_begin, cap->c_end);
-            }
         }
+
+        char* cap_copy = (char*) alloca(cap->length() + 1);
+        long long int i_value;
+        double d_value;
+        int end_index;
+
+        memcpy(cap_copy, cap_start, cap->length());
+        cap_copy[cap->length()] = '\0';
+
+        if (sscanf(cap_copy, "%lld%n", &i_value, &end_index) == 1
+            && (end_index == cap->length()))
+        {
+            return (int64_t) i_value;
+        }
+        if (sscanf(cap_copy, "%lf%n", &d_value, &end_index) == 1
+            && (end_index == cap->length()))
+        {
+            return d_value;
+        }
+        return string_fragment(str, cap->c_begin, cap->c_end);
     } else {
         yajlpp_map root_map(gen);
         column_namer cn;
 
         for (int lpc = 0; lpc < extractor.get_capture_count(); lpc++) {
-            string colname = cn.add_column(extractor.name_for_capture(lpc));
+            std::string colname
+                = cn.add_column(extractor.name_for_capture(lpc));
             pcre_context::capture_t* cap = pc[lpc];
 
             yajl_gen_string(gen, colname);
@@ -225,7 +225,7 @@ logfmt2json(string_fragment line)
                             parse_handle.reset(yajl_alloc(
                                 &json_op::ptr_callbacks, nullptr, &jo));
 
-                            auto json_in
+                            const auto* json_in
                                 = (const unsigned char*) qv.qv_value.data();
                             auto json_len = qv.qv_value.length();
 
@@ -252,7 +252,7 @@ logfmt2json(string_fragment line)
     return json_string(gen);
 }
 
-static string
+static std::string
 regexp_replace(const char* str, const char* re, const char* repl)
 {
     cache_entry* reobj = find_re(re);
@@ -260,14 +260,14 @@ regexp_replace(const char* str, const char* re, const char* repl)
     return reobj->re2->replace(str, repl);
 }
 
-static string
+static std::string
-spooky_hash(const vector<const char*>& args)
+spooky_hash(const std::vector<const char*>& args)
 {
     byte_array<2, uint64> hash;
     SpookyHash context;
 
     context.Init(0, 0);
-    for (const auto arg : args) {
+    for (const auto* const arg : args) {
         int64_t len = arg != nullptr ? strlen(arg) : 0;
 
         context.Update(&len, sizeof(len));
@@ -288,7 +288,7 @@ sql_spooky_hash_step(sqlite3_context* context, int argc, sqlite3_value** argv)
         = (SpookyHash*) sqlite3_aggregate_context(context, sizeof(SpookyHash));
 
     for (int lpc = 0; lpc < argc; lpc++) {
-        auto value = sqlite3_value_text(argv[lpc]);
+        const auto* value = sqlite3_value_text(argv[lpc]);
         int64_t len = value != nullptr ? strlen((const char*) value) : 0;
 
         hasher->Update(&len, sizeof(len));
@@ -312,7 +312,7 @@ sql_spooky_hash_final(sqlite3_context* context)
 
         hasher->Final(hash.out(0), hash.out(1));
 
-        string hex = hash.to_string();
+        auto hex = hash.to_string();
         sqlite3_result_text(
             context, hex.c_str(), hex.length(), SQLITE_TRANSIENT);
     }
@@ -358,8 +358,8 @@ sparkline_final(sqlite3_context* context)
         return;
     }
 
-    auto retval = (char*) malloc(sc->sc_values.size() * 3 + 1);
+    auto* retval = (char*) malloc(sc->sc_values.size() * 3 + 1);
-    auto start = retval;
+    auto* start = retval;
 
     for (const auto& value : sc->sc_values) {
         auto bar = humanize::sparkline(value, sc->sc_max_value);
@@ -380,7 +380,7 @@ sql_gunzip(sqlite3_value* val)
     switch (sqlite3_value_type(val)) {
         case SQLITE3_TEXT:
         case SQLITE_BLOB: {
-            auto buffer = sqlite3_value_blob(val);
+            const auto* buffer = sqlite3_value_blob(val);
             auto len = sqlite3_value_bytes(val);
 
             if (!lnav::gzip::is_gzipped((const char*) buffer, len)) {
@@ -414,7 +414,7 @@ sql_gzip(sqlite3_value* val)
     switch (sqlite3_value_type(val)) {
         case SQLITE3_TEXT:
         case SQLITE_BLOB: {
-            auto buffer = sqlite3_value_blob(val);
+            const auto* buffer = sqlite3_value_blob(val);
             auto len = sqlite3_value_bytes(val);
             auto res = lnav::gzip::compress(buffer, len);
 
@@ -428,7 +428,6 @@ sql_gzip(sqlite3_value* val)
         case SQLITE_INTEGER:
         case SQLITE_FLOAT: {
             auto buffer = sqlite3_value_text(val);
-            log_debug("buf %s", buffer);
             auto res
                 = lnav::gzip::compress(buffer, strlen((const char*) buffer));
 

src/string_attr_type.cc

@@ -35,6 +35,7 @@ string_attr_type SA_ORIGINAL_LINE("original_line");
 string_attr_type SA_BODY("body");
 string_attr_type SA_HIDDEN("hidden");
 string_attr_type SA_FORMAT("format");
+string_attr_type2<const intern_string_t> SA_FORMAT2("format");
 string_attr_type SA_REMOVED("removed");
 string_attr_type SA_INVALID("invalid");
 string_attr_type SA_ERROR("error");

src/string_attr_type.hh

@@ -30,6 +30,13 @@
 #ifndef lnav_string_attr_type_hh
 #define lnav_string_attr_type_hh
 
+#include <utility>
+
+#include <stdint.h>
+
+#include "base/intern_string.hh"
+#include "mapbox/variant.hpp"
+
 class string_attr_type {
 public:
     explicit string_attr_type(const char* name = nullptr) noexcept
@@ -37,12 +44,40 @@ public:
 
     const char* sat_name;
 };
-typedef string_attr_type* string_attr_type_t;
+using string_attr_type_t = string_attr_type*;
+
+using string_attr_value
+    = mapbox::util::variant<int64_t, const intern_string_t, std::string>;
+
+class string_attr_type_base {
+public:
+    explicit string_attr_type_base(const char* name) noexcept : sat_name(name)
+    {
+    }
+
+    const char* const sat_name;
+};
+
+template<typename T>
+class string_attr_type2 : public string_attr_type_base {
+public:
+    explicit string_attr_type2(const char* name) noexcept
+        : string_attr_type_base(name)
+    {
+    }
+
+    std::pair<string_attr_type_base*, string_attr_value> value(const T& val)
+    {
+        return std::make_pair(this, val);
+    }
+};
 
 extern string_attr_type SA_ORIGINAL_LINE;
 extern string_attr_type SA_BODY;
 extern string_attr_type SA_HIDDEN;
 extern string_attr_type SA_FORMAT;
+class intern_string;
+extern string_attr_type2<const intern_string_t> SA_FORMAT2;
 extern string_attr_type SA_REMOVED;
 extern string_attr_type SA_INVALID;
 extern string_attr_type SA_ERROR;

src/styling.cc

@@ -38,31 +38,32 @@
 #include "yajlpp/yajlpp.hh"
 #include "yajlpp/yajlpp_def.hh"
 
-using namespace std;
+static const struct json_path_container term_color_rgb_handler = {
+    yajlpp::property_handler("r").FOR_FIELD(rgb_color, rc_r),
+    yajlpp::property_handler("g").FOR_FIELD(rgb_color, rc_g),
+    yajlpp::property_handler("b").FOR_FIELD(rgb_color, rc_b),
+};
 
-static struct json_path_container term_color_rgb_handler
+static const struct json_path_container term_color_handler = {
-    = {yajlpp::property_handler("r").FOR_FIELD(rgb_color, rc_r),
+    yajlpp::property_handler("colorId").FOR_FIELD(term_color, xc_id),
-       yajlpp::property_handler("g").FOR_FIELD(rgb_color, rc_g),
+    yajlpp::property_handler("name").FOR_FIELD(term_color, xc_name),
-       yajlpp::property_handler("b").FOR_FIELD(rgb_color, rc_b)};
+    yajlpp::property_handler("hexString").FOR_FIELD(term_color, xc_hex),
+    yajlpp::property_handler("rgb")
+        .with_obj_provider<rgb_color, term_color>(
+            [](const auto& pc, term_color* xc) { return &xc->xc_color; })
+        .with_children(term_color_rgb_handler),
+};
 
-static struct json_path_container term_color_handler
+static const struct json_path_container root_color_handler = {
-    = {yajlpp::property_handler("colorId").FOR_FIELD(term_color, xc_id),
+    yajlpp::property_handler("#")
-       yajlpp::property_handler("name").FOR_FIELD(term_color, xc_name),
+        .with_obj_provider<term_color, std::vector<term_color>>(
-       yajlpp::property_handler("hexString").FOR_FIELD(term_color, xc_hex),
+            [](const yajlpp_provider_context& ypc,
-       yajlpp::property_handler("rgb")
+               std::vector<term_color>* palette) {
-           .with_obj_provider<rgb_color, term_color>(
+                palette->resize(ypc.ypc_index + 1);
-               [](const auto& pc, term_color* xc) { return &xc->xc_color; })
+                return &((*palette)[ypc.ypc_index]);
-           .with_children(term_color_rgb_handler)};
+            })
-
+        .with_children(term_color_handler),
-static struct json_path_container root_color_handler
+};
-    = {yajlpp::property_handler("#")
-           .with_obj_provider<term_color, vector<term_color>>(
-               [](const yajlpp_provider_context& ypc,
-                  vector<term_color>* palette) {
-                   palette->resize(ypc.ypc_index + 1);
-                   return &((*palette)[ypc.ypc_index]);
-               })
-           .with_children(term_color_handler)};
 
 term_color_palette*
 xterm_colors()

src/styling.hh

@@ -130,7 +130,7 @@ public:
 
     static color_unit make_empty()
     {
-        return {rgb_color{}};
+        return color_unit{rgb_color{}};
     }
 
     bool empty() const
@@ -145,7 +145,7 @@ public:
     variants_t cu_value;
 
 private:
-    color_unit(variants_t value) : cu_value(std::move(value)) {}
+    explicit color_unit(variants_t value) : cu_value(std::move(value)) {}
 };
 
 }  // namespace styling

src/tailer/drive_tailer.cc

@@ -31,7 +31,7 @@
 
 #include <unistd.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/auto_pid.hh"
 #include "config.h"
 #include "ghc/filesystem.hpp"

src/tailer/tailer.looper.cc

@@ -108,7 +108,7 @@ update_tailer_progress(const std::string& netloc, const std::string& msg)
 static void
 update_tailer_description(
     const std::string& netloc,
-    const std::map<std::string, logfile_open_options>& desired_paths,
+    const std::map<std::string, logfile_open_options_base>& desired_paths,
     const std::string& remote_uname)
 {
     std::vector<std::string> paths;
@@ -182,7 +182,7 @@ tailer::looper::loop_body()
                     for (const auto& pair : paths) {
                         log_debug("adding path to tailer -- %s",
                                   pair.first.c_str());
-                        ht.open_remote_path(pair.first, pair.second);
+                        ht.open_remote_path(pair.first, std::move(pair.second));
                     }
                 });
 
@@ -199,7 +199,7 @@ tailer::looper::loop_body()
 
 void
 tailer::looper::add_remote(const network::path& path,
-                           logfile_open_options options)
+                           logfile_open_options_base options)
 {
     auto netloc_str = fmt::to_string(path.home());
     this->l_netlocs_to_paths[netloc_str].rpq_new_paths[path.p_path]
@@ -488,7 +488,7 @@ tailer::looper::host_tailer::host_tailer(const std::string& netloc,
 
 void
 tailer::looper::host_tailer::open_remote_path(const std::string& path,
-                                              logfile_open_options loo)
+                                              logfile_open_options_base loo)
 {
     this->ht_state.match(
         [&](connected& conn) {
@@ -660,7 +660,7 @@ tailer::looper::host_tailer::loop_body()
                           pob.pob_offset,
                           pob.pob_length);
 
-                logfile_open_options loo;
+                logfile_open_options_base loo;
                 if (pob.pob_path == pob.pob_root_path) {
                     auto root_iter = conn.c_desired_paths.find(pob.pob_path);
 
@@ -670,7 +670,7 @@ tailer::looper::host_tailer::loop_body()
                         return std::move(this->ht_state);
                     }
 
-                    loo = std::move(root_iter->second);
+                    loo = root_iter->second;
                 } else {
                     auto child_iter = conn.c_child_paths.find(pob.pob_path);
                     if (child_iter == conn.c_child_paths.end()) {

src/tailer/tailer.looper.hh

@@ -34,7 +34,7 @@
 
 #include <logfile_fwd.hh>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/auto_pid.hh"
 #include "base/isc.hh"
 #include "base/network.tcp.hh"
@@ -45,7 +45,8 @@ namespace tailer {
 
 class looper : public isc::service<looper> {
 public:
-    void add_remote(const network::path& path, logfile_open_options options);
+    void add_remote(const network::path& path,
+                    logfile_open_options_base options);
 
     void load_preview(int64_t id, const network::path& path);
 
@@ -84,7 +85,7 @@ private:
                     auto_fd err_from_child);
 
         void open_remote_path(const std::string& path,
-                              logfile_open_options loo);
+                              logfile_open_options_base loo);
 
         void load_preview(int64_t id, const std::string& path);
 
@@ -114,8 +115,8 @@ private:
             auto_pid<process_state::running> ht_child;
             auto_fd ht_to_child;
             auto_fd ht_from_child;
-            std::map<std::string, logfile_open_options> c_desired_paths;
+            std::map<std::string, logfile_open_options_base> c_desired_paths;
-            std::map<std::string, logfile_open_options> c_child_paths;
+            std::map<std::string, logfile_open_options_base> c_child_paths;
 
             auto_pid<process_state::finished> close() &&;
         };
@@ -145,8 +146,8 @@ private:
     struct remote_path_queue {
         attempt_time_point rpq_next_attempt_time{
             std::chrono::steady_clock::now()};
-        std::map<std::string, logfile_open_options> rpq_new_paths;
+        std::map<std::string, logfile_open_options_base> rpq_new_paths;
-        std::map<std::string, logfile_open_options> rpq_existing_paths;
+        std::map<std::string, logfile_open_options_base> rpq_existing_paths;
 
         void send_synced_to_main(const std::string& netloc);
     };

src/textfile_highlighters.cc

@@ -33,8 +33,6 @@
 
 #include "config.h"
 
-using namespace std;
-
 static pcre*
 xpcre_compile(const char* pattern, int options = 0)
 {

src/textview_curses.cc

@@ -43,8 +43,6 @@
 #include "shlex.hh"
 #include "view_curses.hh"
 
-using namespace std;
-
 const auto REVERSE_SEARCH_OFFSET = 2000_vl;
 
 void
@@ -143,7 +141,7 @@ textview_curses::~textview_curses()
 void
 textview_curses::reload_config(error_reporter& reporter)
 {
-    const static auto DEFAULT_THEME_NAME = string("default");
+    const static auto DEFAULT_THEME_NAME = std::string("default");
 
     for (auto iter = this->tc_highlights.begin();
          iter != this->tc_highlights.end();)
@@ -196,7 +194,7 @@ textview_curses::reload_config(error_reporter& reporter)
             }
 
             const auto& sc = hl_pair.second.hc_style;
-            string fg1, bg1, fg_color, bg_color, errmsg;
+            std::string fg1, bg1, fg_color, bg_color, errmsg;
             bool invalid = false;
             int attrs = 0;
 
@@ -334,7 +332,7 @@ textview_curses::grep_match(grep_proc<vis_line_t>& gp,
 void
 textview_curses::listview_value_for_rows(const listview_curses& lv,
                                          vis_line_t row,
-                                         vector<attr_line_t>& rows_out)
+                                         std::vector<attr_line_t>& rows_out)
 {
     for (auto& al : rows_out) {
         this->textview_value_for_row(row, al);
@@ -428,9 +426,9 @@ textview_curses::handle_mouse(mouse_event& me)
 void
 textview_curses::textview_value_for_row(vis_line_t row, attr_line_t& value_out)
 {
-    string_attrs_t& sa = value_out.get_attrs();
+    auto& sa = value_out.get_attrs();
-    string& str = value_out.get_string();
+    auto& str = value_out.get_string();
-    text_format_t source_format = this->tc_sub_source->get_text_format();
+    auto source_format = this->tc_sub_source->get_text_format();
     intern_string_t format_name;
 
     this->tc_sub_source->text_value_for_line(*this, row, str);
@@ -577,7 +575,7 @@ textview_curses::execute_search(const std::string& regex_orig)
                         regex.c_str(), PCRE_CASELESS, &errptr, &eoff, nullptr))
                    == nullptr)
         {
-            string errmsg = string(errptr);
+            auto errmsg = std::string(errptr);
 
             regex = pcrepp::quote(regex);
 
@@ -598,8 +596,7 @@ textview_curses::execute_search(const std::string& regex_orig)
             highlight_map_t& hm = this->get_highlights();
             hm[{highlight_source_t::PREVIEW, "search"}] = hl;
 
-            unique_ptr<grep_proc<vis_line_t>> gp
+            auto gp = std::make_unique<grep_proc<vis_line_t>>(code, *this);
-                = make_unique<grep_proc<vis_line_t>>(code, *this);
 
             gp->set_sink(this);
             auto top = this->get_top();
@@ -619,8 +616,8 @@ textview_curses::execute_search(const std::string& regex_orig)
 
             if (this->tc_sub_source != nullptr) {
                 this->tc_sub_source->get_grepper() | [this, code](auto pair) {
-                    shared_ptr<grep_proc<vis_line_t>> sgp
+                    auto sgp = std::make_shared<grep_proc<vis_line_t>>(
-                        = make_shared<grep_proc<vis_line_t>>(code, *pair.first);
+                        code, *pair.first);
 
                     sgp->set_sink(pair.second);
                     sgp->queue_request(0_vl);
@@ -642,7 +639,7 @@ void
 textview_curses::horiz_shift(vis_line_t start,
                              vis_line_t end,
                              int off_start,
-                             pair<int, int>& range_out)
+                             std::pair<int, int>& range_out)
 {
     highlighter& hl
         = this->tc_highlights[{highlight_source_t::PREVIEW, "search"}];
@@ -799,7 +796,7 @@ empty_filter::matches(const logfile& lf,
     return false;
 }
 
-string
+std::string
 empty_filter::to_command() const
 {
     return "";

src/time-extension-functions.cc

@@ -41,8 +41,6 @@
 #include "sql_util.hh"
 #include "vtab_module.hh"
 
-using namespace std;
-
 static nonstd::optional<text_auto_buffer>
 timeslice(sqlite3_value* time_in, nonstd::optional<const char*> slice_in_opt)
 {

src/url_loader.hh

@@ -51,7 +51,7 @@ public:
 
         auto tmp_pair = tmp_res.unwrap();
         ghc::filesystem::remove(tmp_pair.first);
-        this->ul_fd = tmp_pair.second;
+        this->ul_fd = std::move(tmp_pair.second);
 
         curl_easy_setopt(this->cr_handle, CURLOPT_URL, this->cr_name.c_str());
         curl_easy_setopt(this->cr_handle, CURLOPT_WRITEFUNCTION, write_cb);
@@ -66,7 +66,7 @@ public:
 
     auto_fd copy_fd() const
     {
-        return this->ul_fd;
+        return this->ul_fd.dup();
     };
 
     long complete(CURLcode result)

src/view_helpers.cc

@@ -40,18 +40,18 @@
 #include "view_helpers.examples.hh"
 #include "vtab_module.hh"
 
-using namespace std;
+const char* lnav_view_strings[LNV__MAX + 1] = {
+    "log",
+    "text",
+    "help",
+    "histogram",
+    "db",
+    "schema",
+    "pretty",
+    "spectro",
 
-const char* lnav_view_strings[LNV__MAX + 1] = {"log",
+    nullptr,
-                                               "text",
+};
-                                               "help",
-                                               "histogram",
-                                               "db",
-                                               "schema",
-                                               "pretty",
-                                               "spectro",
-
-                                               nullptr};
 
 nonstd::optional<lnav_view_t>
 view_from_string(const char* name)
@@ -61,13 +61,13 @@ view_from_string(const char* name)
     }
 
     auto view_name_iter
-        = find_if(::begin(lnav_view_strings),
+        = std::find_if(std::begin(lnav_view_strings),
-                  ::end(lnav_view_strings),
+                       std::end(lnav_view_strings),
-                  [&](const char* v) {
+                       [&](const char* v) {
-                      return v != nullptr && strcasecmp(v, name) == 0;
+                           return v != nullptr && strcasecmp(v, name) == 0;
-                  });
+                       });
 
-    if (view_name_iter == ::end(lnav_view_strings)) {
+    if (view_name_iter == std::end(lnav_view_strings)) {
         return nonstd::nullopt;
     }
 
@@ -78,7 +78,7 @@ static void
 open_schema_view()
 {
     textview_curses* schema_tc = &lnav_data.ld_views[LNV_SCHEMA];
-    string schema;
+    std::string schema;
 
     dump_sqlite_schema(lnav_data.ld_db, schema);
 
@@ -123,7 +123,7 @@ open_pretty_view()
         for (vis_line_t vl = log_tc->get_top(); vl <= log_tc->get_bottom();
              ++vl) {
             content_line_t cl = lss.at(vl);
-            shared_ptr<logfile> lf = lss.find(cl);
+            auto lf = lss.find(cl);
             auto ll = lf->begin() + cl;
             shared_buffer_ref sbr;
 
@@ -153,7 +153,7 @@ open_pretty_view()
             data_scanner ds(orig_al.get_string());
             pretty_printer pp(&ds, orig_al.get_attrs());
             attr_line_t pretty_al;
-            vector<attr_line_t> pretty_lines;
+            std::vector<attr_line_t> pretty_lines;
 
             // TODO: dump more details of the line in the output.
             pp.append_to(pretty_al);
@@ -176,7 +176,7 @@ open_pretty_view()
             full_text.erase(full_text.length() - 1, 1);
         }
     } else if (top_tc == text_tc) {
-        shared_ptr<logfile> lf = lnav_data.ld_text_source.current_file();
+        auto lf = lnav_data.ld_text_source.current_file();
 
         for (vis_line_t vl = text_tc->get_top(); vl <= text_tc->get_bottom();
              ++vl) {
@@ -210,14 +210,14 @@ build_all_help_text()
 
     attr_line_t all_help_text;
     shlex lexer(help_txt.to_string_fragment());
-    string sub_help_text;
+    std::string sub_help_text;
 
     lexer.with_ignore_quotes(true).eval(
         sub_help_text, lnav_data.ld_exec_context.ec_global_vars);
     all_help_text.with_ansi_string(sub_help_text);
 
-    map<string, help_text*> sql_funcs;
+    std::map<std::string, help_text*> sql_funcs;
-    map<string, help_text*> sql_keywords;
+    std::map<std::string, help_text*> sql_keywords;
 
     for (const auto& iter : sqlite_function_help) {
         switch (iter.second->ht_context) {
@@ -293,7 +293,7 @@ layout_views()
         ? 0
         : lnav_data.ld_preview_source.text_line_count();
     int match_rows = lnav_data.ld_match_source.text_line_count();
-    int match_height = min((unsigned long) match_rows, (height - 4) / 2);
+    int match_height = std::min((unsigned long) match_rows, (height - 4) / 2);
 
     lnav_data.ld_match_view.set_height(vis_line_t(match_height));
 
@@ -376,7 +376,7 @@ layout_views()
     lnav_data.ld_rl_view->set_width(width);
 }
 
-static unordered_map<string, attr_line_t> EXAMPLE_RESULTS;
+static std::unordered_map<std::string, attr_line_t> EXAMPLE_RESULTS;
 
 void
 execute_examples()
@@ -389,7 +389,7 @@ execute_examples()
         struct help_text& ht = *(help_iter.second);
 
         for (auto& ex : ht.ht_example) {
-            string alt_msg;
+            std::string alt_msg;
             attr_line_t result;
 
             if (!ex.he_cmd) {
@@ -461,7 +461,7 @@ toggle_view(textview_curses* toggle_tc)
     textview_curses* tc = lnav_data.ld_view_stack.top().value_or(nullptr);
     bool retval = false;
 
-    require(toggle_tc != NULL);
+    require(toggle_tc != nullptr);
     require(toggle_tc >= &lnav_data.ld_views[0]);
     require(toggle_tc < &lnav_data.ld_views[LNV__MAX]);
 
@@ -536,9 +536,11 @@ next_cluster(vis_line_t (bookmark_vector<vis_line_t>::*f)(vis_line_t) const,
         hit_count += 1;
         if (!top_is_marked || diff > 1) {
             return new_top;
-        } else if (hit_count > 1 && std::abs(new_top - top) >= tc_height) {
+        }
+        if (hit_count > 1 && std::abs(new_top - top) >= tc_height) {
             return vis_line_t(new_top - diff);
-        } else if (diff < -1) {
+        }
+        if (diff < -1) {
             last_top = new_top;
             while ((new_top = (bv.*f)(new_top)) != -1) {
                 if ((std::abs(last_top - new_top) > 1)

src/vt52_curses.cc

@@ -57,8 +57,6 @@
 #    error "SysV or X/Open-compatible Curses header file required"
 #endif
 
-using namespace std;
-
 /**
  * Singleton used to hold the mapping of ncurses keycodes to VT52 escape
  * sequences.
@@ -79,10 +77,10 @@ public:
      */
     const char* operator[](int ch) const
     {
-        map<int, const char*>::const_iterator iter;
+        auto iter = this->vem_map.find(ch);
         const char* retval = nullptr;
 
-        if ((iter = this->vem_map.find(ch)) == this->vem_map.end()) {
+        if (iter == this->vem_map.end()) {
             if (ch > KEY_MAX) {
                 auto name = keyname(ch);
 
@@ -104,7 +102,7 @@ public:
 
     const char* operator[](const char* seq) const
     {
-        map<string, const char*>::const_iterator iter;
+        std::map<std::string, const char*>::const_iterator iter;
         const char* retval = nullptr;
 
         require(seq != nullptr);
@@ -162,8 +160,8 @@ private:
     };
 
     /** Map of ncurses keycodes to VT52 escape sequences. */
-    mutable map<int, const char*> vem_map;
+    mutable std::map<int, const char*> vem_map;
-    map<string, const char*> vem_input_map;
+    std::map<std::string, const char*> vem_input_map;
 };
 
 const char*

src/xpath_vtab.cc

@@ -39,8 +39,6 @@
 #include "xml_util.hh"
 #include "yajlpp/yajlpp.hh"
 
-using namespace std;
-
 enum {
     XP_COL_RESULT,
     XP_COL_NODE_PATH,
@@ -104,8 +102,8 @@ CREATE TABLE xpath (
     struct cursor {
         sqlite3_vtab_cursor base;
         sqlite3_int64 c_rowid{0};
-        string c_xpath;
+        std::string c_xpath;
-        string c_value;
+        std::string c_value;
         bool c_value_as_blob{false};
         pugi::xpath_query c_query;
         pugi::xml_document c_doc;
@@ -153,7 +151,7 @@ CREATE TABLE xpath (
                 auto& xpath_node = vc.c_results[vc.c_rowid];
 
                 if (xpath_node.node()) {
-                    ostringstream oss;
+                    std::ostringstream oss;
 
                     // XXX avoid the extra allocs
                     xpath_node.node().print(oss);
@@ -356,29 +354,35 @@ register_xpath_vtab(sqlite3* db)
                     "over an XML "
                     "string and returns the selected values.")
               .sql_table_valued_function()
-              .with_parameter(
+              .with_parameter({
-                  {"xpath",
+                  "xpath",
-                   "The XPATH expression to evaluate over the XML document."})
+                  "The XPATH expression to evaluate over the XML document.",
+              })
               .with_parameter({"xmldoc", "The XML document as a string."})
               .with_result({"result", "The result of the XPATH expression."})
-              .with_result(
+              .with_result({
-                  {"node_path",
+                  "node_path",
-                   "The absolute path to the node containing the result."})
+                  "The absolute path to the node containing the result.",
+              })
               .with_result(
                   {"node_attr", "The node's attributes stored in JSON object."})
               .with_result({"node_text", "The node's text value."})
               .with_tags({"string", "xml"})
-              .with_example({"To select the XML nodes on the path '/abc/def'",
+              .with_example({
-                             "SELECT * FROM xpath('/abc/def', '<abc><def "
+                  "To select the XML nodes on the path '/abc/def'",
-                             "a=\"b\">Hello</def><def>Bye</def></abc>')"})
+                  "SELECT * FROM xpath('/abc/def', '<abc><def "
-              .with_example(
+                  "a=\"b\">Hello</def><def>Bye</def></abc>')",
-                  {"To select all 'a' attributes on the path '/abc/def'",
+              })
-                   "SELECT * FROM xpath('/abc/def/@a', '<abc><def "
+              .with_example({
-                   "a=\"b\">Hello</def><def>Bye</def></abc>')"})
+                  "To select all 'a' attributes on the path '/abc/def'",
-              .with_example(
+                  "SELECT * FROM xpath('/abc/def/@a', '<abc><def "
-                  {"To select the text nodes on the path '/abc/def'",
+                  "a=\"b\">Hello</def><def>Bye</def></abc>')",
-                   "SELECT * FROM xpath('/abc/def/text()', '<abc><def "
+              })
-                   "a=\"b\">Hello &#x2605;</def></abc>')"});
+              .with_example({
+                  "To select the text nodes on the path '/abc/def'",
+                  "SELECT * FROM xpath('/abc/def/text()', '<abc><def "
+                  "a=\"b\">Hello &#x2605;</def></abc>')",
+              });
 
     int rc;
 
@@ -386,7 +390,7 @@ register_xpath_vtab(sqlite3* db)
     XPATH_MODULE.vm_module.xFilter = rcFilter;
 
     rc = XPATH_MODULE.create(db, "xpath");
-    sqlite_function_help.insert(make_pair("xpath", &xpath_help));
+    sqlite_function_help.insert(std::make_pair("xpath", &xpath_help));
     xpath_help.index_tags();
 
     ensure(rc == SQLITE_OK);

src/yajlpp/drive_json_ptr_walk.cc

@@ -40,8 +40,6 @@
 #include "yajl/api/yajl_gen.h"
 #include "yajlpp.hh"
 
-using namespace std;
-
 int
 main(int argc, char* argv[])
 {
@@ -51,7 +49,7 @@ main(int argc, char* argv[])
 
     log_argv(argc, argv);
 
-    std::string json_input(std::istreambuf_iterator<char>(cin), {});
+    std::string json_input(std::istreambuf_iterator<char>(std::cin), {});
 
     status = jpw.parse(json_input.c_str(), json_input.size());
     if (status == yajl_status_error) {

src/yajlpp/json_ptr.cc

@@ -38,8 +38,6 @@
 #include "yajl/api/yajl_gen.h"
 #include "yajlpp/json_ptr.hh"
 
-using namespace std;
-
 static int
 handle_null(void* ctx)
 {
@@ -70,7 +68,7 @@ handle_number(void* ctx, const char* numberVal, size_t numberLen)
     json_ptr_walk* jpw = (json_ptr_walk*) ctx;
 
     jpw->jpw_values.emplace_back(
-        jpw->current_ptr(), yajl_t_number, string(numberVal, numberLen));
+        jpw->current_ptr(), yajl_t_number, std::string(numberVal, numberLen));
     jpw->inc_array_index();
 
     return 1;
@@ -79,7 +77,7 @@ handle_number(void* ctx, const char* numberVal, size_t numberLen)
 static void
 appender(void* ctx, const char* strVal, size_t strLen)
 {
-    string& str = *(string*) ctx;
+    std::string& str = *(std::string*) ctx;
 
     str.append(strVal, strLen);
 }
@@ -89,7 +87,7 @@ handle_string(void* ctx, const unsigned char* stringVal, size_t len)
 {
     json_ptr_walk* jpw = (json_ptr_walk*) ctx;
     auto_mem<yajl_gen_t> gen(yajl_gen_free);
-    string str;
+    std::string str;
 
     gen = yajl_gen_alloc(nullptr);
     yajl_gen_config(gen.in(), yajl_gen_print_callback, appender, &str);

src/yajlpp/yajlpp.cc

@@ -39,12 +39,10 @@
 #include "yajl/api/yajl_parse.h"
 #include "yajlpp_def.hh"
 
-using namespace std;
-
 const json_path_handler_base::enum_value_t
     json_path_handler_base::ENUM_TERMINATOR((const char*) nullptr, 0);
 
-json_path_handler_base::json_path_handler_base(const string& property)
+json_path_handler_base::json_path_handler_base(const std::string& property)
     : jph_property(property.back() == '#'
                        ? property.substr(0, property.size() - 1)
                        : property),
@@ -70,10 +68,10 @@ json_path_handler_base::json_path_handler_base(const pcrepp& property)
     memset(&this->jph_callbacks, 0, sizeof(this->jph_callbacks));
 }
 
-json_path_handler_base::json_path_handler_base(string property,
+json_path_handler_base::json_path_handler_base(std::string property,
                                                const pcrepp& property_re)
     : jph_property(std::move(property)), jph_regex(property_re),
-      jph_is_array(property_re.p_pattern.find('#') != string::npos)
+      jph_is_array(property_re.p_pattern.find('#') != std::string::npos)
 {
     memset(&this->jph_callbacks, 0, sizeof(this->jph_callbacks));
 }
@@ -81,7 +79,7 @@ json_path_handler_base::json_path_handler_base(string property,
 yajl_gen_status
 json_path_handler_base::gen(yajlpp_gen_context& ygc, yajl_gen handle) const
 {
-    vector<string> local_paths;
+    std::vector<std::string> local_paths;
 
     if (this->jph_path_provider) {
         this->jph_path_provider(ygc.ygc_obj_stack.top(), local_paths);
@@ -91,7 +89,7 @@ json_path_handler_base::gen(yajlpp_gen_context& ygc, yajl_gen handle) const
 
     if (this->jph_children) {
         for (const auto& lpath : local_paths) {
-            string full_path = lpath;
+            std::string full_path = lpath;
             if (this->jph_path_provider) {
                 full_path += "/";
             }
@@ -180,7 +178,8 @@ json_path_handler_base::gen_schema(yajlpp_gen_context& ygc) const
                                        fmt::join(ygc.ygc_path, "/")));
                 schema.gen("type");
                 if (this->jph_is_array) {
-                    if (this->jph_regex.p_pattern.find("#?") == string::npos) {
+                    if (this->jph_regex.p_pattern.find("#?")
+                        == std::string::npos) {
                         schema.gen("array");
                     } else {
                         yajlpp_array type_array(ygc.ygc_handle);
@@ -231,7 +230,7 @@ json_path_handler_base::gen_schema(yajlpp_gen_context& ygc) const
         schema.gen("type");
 
         if (this->jph_is_array) {
-            if (this->jph_regex.p_pattern.find("#?") == string::npos) {
+            if (this->jph_regex.p_pattern.find("#?") == std::string::npos) {
                 schema.gen("array");
             } else {
                 yajlpp_array type_array(ygc.ygc_handle);
@@ -327,9 +326,9 @@ json_path_handler_base::walk(
     const std::function<
         void(const json_path_handler_base&, const std::string&, void*)>& cb,
     void* root,
-    const string& base) const
+    const std::string& base) const
 {
-    vector<string> local_paths;
+    std::vector<std::string> local_paths;
 
     if (this->jph_path_provider) {
         this->jph_path_provider(root, local_paths);
@@ -340,7 +339,7 @@ json_path_handler_base::walk(
     } else {
         local_paths.emplace_back(this->jph_property);
 
-        string full_path = base + this->jph_property;
+        std::string full_path = base + this->jph_property;
         if (this->jph_children) {
             full_path += "/";
         }
@@ -350,7 +349,7 @@ json_path_handler_base::walk(
     if (this->jph_children) {
         for (const auto& lpath : local_paths) {
             for (auto& jph : this->jph_children->jpc_children) {
-                string full_path = base + lpath;
+                std::string full_path = base + lpath;
                 if (this->jph_children) {
                     full_path += "/";
                 }
@@ -363,7 +362,7 @@ json_path_handler_base::walk(
 
                 ypc.set_path(full_path).with_obj(root).update_callbacks();
                 if (this->jph_obj_provider) {
-                    string full_path = lpath + "/";
+                    std::string full_path = lpath + "/";
                     pcre_input pi(full_path);
 
                     if (!this->jph_regex.match(ypc.ypc_pcre_context, pi)) {
@@ -402,7 +401,7 @@ json_path_handler_base::to_enum_value(const string_fragment& sf) const
     return nonstd::nullopt;
 }
 
-vector<json_path_handler_base::schema_type_t>
+std::vector<json_path_handler_base::schema_type_t>
 json_path_handler_base::get_types() const
 {
     std::vector<schema_type_t> retval;
@@ -537,7 +536,7 @@ yajlpp_parse_context::update_callbacks(const json_path_container* orig_handlers,
     }
 
     if (!this->ypc_active_paths.empty()) {
-        string curr_path(&this->ypc_path[0], this->ypc_path.size() - 1);
+        std::string curr_path(&this->ypc_path[0], this->ypc_path.size() - 1);
 
         if (this->ypc_active_paths.find(curr_path)
             == this->ypc_active_paths.end()) {
@@ -889,20 +888,25 @@ yajlpp_parse_context::set_static_handler(json_path_handler_base& jph)
     this->ypc_path.push_back('\0');
     this->ypc_path_index_stack.clear();
     this->ypc_array_index.clear();
-    if (jph.jph_callbacks.yajl_null != nullptr)
+    if (jph.jph_callbacks.yajl_null != nullptr) {
         this->ypc_callbacks.yajl_null = jph.jph_callbacks.yajl_null;
-    if (jph.jph_callbacks.yajl_boolean != nullptr)
+    }
+    if (jph.jph_callbacks.yajl_boolean != nullptr) {
         this->ypc_callbacks.yajl_boolean = jph.jph_callbacks.yajl_boolean;
-    if (jph.jph_callbacks.yajl_integer != nullptr)
+    }
+    if (jph.jph_callbacks.yajl_integer != nullptr) {
         this->ypc_callbacks.yajl_integer = jph.jph_callbacks.yajl_integer;
-    if (jph.jph_callbacks.yajl_double != nullptr)
+    }
+    if (jph.jph_callbacks.yajl_double != nullptr) {
         this->ypc_callbacks.yajl_double = jph.jph_callbacks.yajl_double;
-    if (jph.jph_callbacks.yajl_string != nullptr)
+    }
+    if (jph.jph_callbacks.yajl_string != nullptr) {
         this->ypc_callbacks.yajl_string = jph.jph_callbacks.yajl_string;
+    }
 }
 
 yajlpp_parse_context&
-yajlpp_parse_context::set_path(const string& path)
+yajlpp_parse_context::set_path(const std::string& path)
 {
     this->ypc_path.resize(path.size() + 1);
     std::copy(path.begin(), path.end(), this->ypc_path.begin());
@@ -950,7 +954,7 @@ yajlpp_parse_context::get_path_fragment(int offset,
 int
 yajlpp_parse_context::get_line_number() const
 {
-    if (this->ypc_handle != NULL && this->ypc_json_text) {
+    if (this->ypc_handle != nullptr && this->ypc_json_text) {
         size_t consumed = yajl_get_bytes_consumed(this->ypc_handle);
         long current_count = std::count(
             &this->ypc_json_text[0], &this->ypc_json_text[consumed], '\n');
@@ -966,7 +970,7 @@ yajlpp_gen_context::gen()
 {
     yajlpp_map root(this->ygc_handle);
 
-    for (auto& jph : this->ygc_handlers->jpc_children) {
+    for (const auto& jph : this->ygc_handlers->jpc_children) {
         jph.gen(*this, this->ygc_handle);
     }
 }
@@ -1079,7 +1083,7 @@ json_path_container::gen_properties(yajlpp_gen_context& ygc) const
         {
             yajlpp_map properties(ygc.ygc_handle);
 
-            for (auto& child_handler : this->jpc_children) {
+            for (const auto& child_handler : this->jpc_children) {
                 if (!child_handler.jph_is_pattern_property) {
                     continue;
                 }
@@ -1107,7 +1111,7 @@ dump_schema_to(const json_path_container& jpc,
     yajlpp_gen genner;
     yajlpp_gen_context ygc(genner, jpc);
     auto schema_path = fmt::format(FMT_STRING("{}/{}"), internals_dir, name);
-    auto file = unique_ptr<FILE, decltype(&fclose)>(
+    auto file = std::unique_ptr<FILE, decltype(&fclose)>(
         fopen(schema_path.c_str(), "w+"), fclose);
 
     if (!file.get()) {

test/aftest.cc

@@ -31,7 +31,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 
 void
 foo(int* fd)

test/drive_data_scanner.cc

@@ -48,8 +48,6 @@
 #include "pretty_printer.hh"
 #include "shared_buffer.hh"
 
-using namespace std;
-
 const char* TMP_NAME = "scanned.tmp";
 
 int
@@ -71,7 +69,7 @@ main(int argc, char* argv[])
 
     {
         std::vector<ghc::filesystem::path> paths;
-        vector<string> errors;
+        std::vector<std::string> errors;
 
         load_formats(paths, errors);
     }
@@ -105,14 +103,14 @@ main(int argc, char* argv[])
         retval = EXIT_FAILURE;
     } else {
         for (int lpc = 0; lpc < argc; lpc++) {
-            std::unique_ptr<ifstream> in_ptr;
+            std::unique_ptr<std::ifstream> in_ptr;
-            istream* in;
+            std::istream* in;
             FILE* out;
 
             if (strcmp(argv[lpc], "-") == 0) {
-                in = &cin;
+                in = &std::cin;
             } else {
-                auto ifs = std::make_unique<ifstream>(argv[lpc]);
+                auto ifs = std::make_unique<std::ifstream>(argv[lpc]);
 
                 if (!ifs->is_open()) {
                     fprintf(stderr, "error: unable to open file\n");
@@ -128,11 +126,11 @@ main(int argc, char* argv[])
                         "error: unable to temporary file for writing\n");
                 retval = EXIT_FAILURE;
             } else {
-                shared_ptr<log_format> format;
+                std::shared_ptr<log_format> format;
                 char* log_line;
                 bool found = false;
                 char cmd[2048];
-                string line;
+                std::string line;
                 int rc;
 
                 getline(*in, line);
@@ -142,7 +140,7 @@ main(int argc, char* argv[])
 
                 log_line = (char*) alloca(line.length());
                 strcpy(log_line, &line[13]);
-                string sub_line = line.substr(13);
+                auto sub_line = line.substr(13);
                 struct line_range body(0, sub_line.length());
                 shared_buffer share_manager;
                 shared_buffer_ref sbr;
@@ -151,8 +149,8 @@ main(int argc, char* argv[])
                     share_manager, (char*) sub_line.c_str(), sub_line.size());
 
                 auto& root_formats = log_format::get_root_formats();
-                vector<std::shared_ptr<log_format>>::iterator iter;
+                std::vector<std::shared_ptr<log_format>>::iterator iter;
-                vector<logline> index;
+                std::vector<logline> index;
 
                 if (is_log) {
                     for (iter = root_formats.begin();
@@ -175,7 +173,7 @@ main(int argc, char* argv[])
                     }
                 }
 
-                vector<logline_value> ll_values;
+                std::vector<logline_value> ll_values;
                 string_attrs_t sa;
 
                 if (format.get() != nullptr) {
@@ -187,7 +185,7 @@ main(int argc, char* argv[])
 
                 data_scanner ds(sub_line, body.lr_start, sub_line.length());
                 data_parser dp(&ds);
-                string msg_format;
+                std::string msg_format;
 
                 dp.dp_msg_format = &msg_format;
                 dp.parse();

test/drive_line_buffer.cc

@@ -41,7 +41,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "base/string_util.hh"
 #include "config.h"
 #include "line_buffer.hh"

test/scripty.cc

@@ -77,7 +77,7 @@
 #include <string>
 #include <utility>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "auto_mem.hh"
 #include "base/string_util.hh"
 #include "fmt/format.h"

test/test_auto_fd.cc

@@ -33,7 +33,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "config.h"
 
 int
@@ -62,7 +62,7 @@ main(int argc, char* argv[])
     assert(errno == EBADF);
 
     {
-        auto_fd fd_cp(const_cast<const auto_fd&>(fd1));
+        auto_fd fd_cp(fd1.dup());
 
         assert(fd1 == STDOUT_FILENO);
         assert(fd_cp != STDOUT_FILENO);
@@ -71,7 +71,7 @@ main(int argc, char* argv[])
         tmp = (int) fd_cp;
     }
     {
-        auto_fd fd_cp(const_cast<const auto_fd&>(fd1));
+        auto_fd fd_cp(fd1.dup());
 
         assert(fd_cp == tmp);
     }

test/test_cli.sh

@@ -1,7 +1,7 @@
 #! /bin/bash
 
 export TZ="UTC"
-run_test ${lnav_test} -t -n <<EOF
+run_test ${lnav_test} -d /tmp/lnav.err -t -n <<EOF
 Hello, World!
 Goodbye, World!
 EOF

test/test_line_buffer2.cc

@@ -32,7 +32,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "auto_fd.hh"
+#include "base/auto_fd.hh"
 #include "config.h"
 #include "line_buffer.hh"
 

test/test_logfile.sh

@@ -3,6 +3,16 @@
 echo ${top_srcdir}
 echo ${top_builddir}
 
+
+run_test ${lnav_test} -d /tmp/lnav.err -n -w logfile_stdin.0.log \
+    -c ':shexec sleep 1 && touch -t 200711030923 logfile_stdin.0.log' <<EOF
+2013-06-06T19:13:20.123  Hi
+EOF
+
+check_output "piping to stdin is not working?" <<EOF
+2013-06-06T19:13:20.123  Hi
+EOF
+
 if test x"${TSHARK_CMD}" != x""; then
   run_test env TZ=UTC ${lnav_test} -n ${test_dir}/dhcp.pcapng
 
@@ -20,15 +30,6 @@ error: unable to open file: {test_dir}/dhcp-trunc.pcapng -- tshark: The file "{t
 EOF
 fi
 
-run_test ${lnav_test} -d /tmp/lnav.err -n -w logfile_stdin.0.log \
-    -c ':shexec sleep 1 && touch -t 200711030923 logfile_stdin.0.log' <<EOF
-2013-06-06T19:13:20.123  Hi
-EOF
-
-check_output "piping to stdin is not working?" <<EOF
-2013-06-06T19:13:20.123  Hi
-EOF
-
 
 cp ${srcdir}/logfile_syslog.0 truncfile.0
 chmod u+w truncfile.0
@@ -171,7 +172,7 @@ EOF
         > test_logfile.rotmp.out
     cp test_logfile.rotmp.out `test_err_filename`
     check_error_output "archive not unpacked" <<EOF
-error: unable to open file: /test-logs.tgz -- unable to write entry: rotmp/lnav-user-NNN-work/archives/arc-NNN-test-logs.tgz/test/logfile_access_log.0 -- ...
+error: unable to open file: /test-logs.tgz -- Unable to create directory: rotmp/lnav-user-NNN-work/archives -- Permission denied
 EOF
 fi