[nits] fixing some minor bugs

Author: tstack

src/base/ansi_scrubber.cc

@@ -73,7 +73,7 @@ erase_ansi_escapes(string_fragment input)
         auto sf = md[0].value();
 
         if (sf == "\x00"_frag) {
-            *input.writable_data(0) = ' ';
+            *input.writable_data(fill_index) = ' ';
             move_start = sf.sf_end;
             fill_index += 1;
             continue;
@@ -169,7 +169,7 @@ scrub_ansi_string(std::string& str, string_attrs_t* sa)
         if (sf == "\x00"_frag) {
             str[cp_dst] = ' ';
             cp_start = sf.sf_end;
-            cp_dst = sf.sf_end;
+            cp_dst += 1;
             continue;
         }
 
@@ -365,7 +365,14 @@ scrub_ansi_string(std::string& str, string_attrs_t* sa)
                                     if ((sep1 == ';' && sep2 == ';')
                                         || (sep1 == ':' && sep2 == ':'))
                                     {
-                                        attrs.ta_fg_color = rgb_color{r, g, b};
+                                        if (ansi_code == 38) {
+                                            attrs.ta_fg_color
+                                                = rgb_color{r, g, b};
+                                        } else {
+                                            attrs.ta_bg_color
+                                                = rgb_color{r, g, b};
+                                        }
+                                        seq = color_code_pair->second;
                                     }
                                 }
                             } else if (color_type->value() == 5) {

src/base/auto_fd.cc

@@ -171,6 +171,9 @@ auto_fd::write_fully(string_fragment sf)
         auto rc = write(this->af_fd, sf.data(), sf.length());
 
         if (rc < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
             return Err(
                 fmt::format(FMT_STRING("failed to write {} bytes to FD {}"),
                             sf.length(),
@@ -236,6 +239,8 @@ auto_pipe::after_fork(pid_t child_pid)
                 if (new_fd != this->ap_child_fd) {
                     dup2(new_fd, this->ap_child_fd);
                     this->close();
+                } else {
+                    fcntl(new_fd, F_SETFD, 0);
                 }
             }
             break;

src/base/fs_util.cc

@@ -453,21 +453,21 @@ write_file(const std::filesystem::path& path,
     auto tmp_pair = TRY(open_temp_file(tmp_pattern));
     auto for_res = content.for_each(
         [&tmp_pair](string_fragment sf) -> Result<void, std::string> {
-            auto bytes_written
-                = write(tmp_pair.second.get(), sf.data(), sf.length());
-            if (bytes_written < 0) {
-                return Err(fmt::format(
-                    FMT_STRING("unable to write to temporary file {}: {}"),
-                    tmp_pair.first.string(),
-                    lnav::from_errno()));
-            }
+            while (!sf.empty()) {
+                auto bytes_written
+                    = write(tmp_pair.second.get(), sf.data(), sf.length());
+                if (bytes_written < 0) {
+                    if (errno == EINTR) {
+                        continue;
+                    }
+                    return Err(fmt::format(
+                        FMT_STRING(
+                            "unable to write to temporary file {}: {}"),
+                        tmp_pair.first.string(),
+                        lnav::from_errno()));
+                }
 
-            if (bytes_written != sf.length()) {
-                return Err(
-                    fmt::format(FMT_STRING("short write to file {}: {} < {}"),
-                                tmp_pair.first.string(),
-                                bytes_written,
-                                sf.length()));
+                sf = sf.substr(bytes_written);
             }
 
             return Ok();
@@ -568,8 +568,8 @@ formatter<std::filesystem::path>::format(const std::filesystem::path& p,
                                          format_context& ctx)
     -> decltype(ctx.out()) const
 {
-    auto esc_res = fmt::v10::detail::find_escape(&(*p.native().begin()),
-                                                 &(*p.native().end()));
+    auto esc_res = fmt::v10::detail::find_escape(
+        p.native().data(), p.native().data() + p.native().size());
     if (esc_res.end == nullptr) {
         return formatter<string_view>::format(p.native(), ctx);
     }

src/base/humanize.cc

@@ -75,6 +75,9 @@ try_from(const string_fragment& sf)
     if (md[real]) {
         auto scan_res = scn::scan_value<double>(md[real]->to_string_view());
 
+        if (!scan_res) {
+            return std::nullopt;
+        }
         return scan_res->value();
     }
 
@@ -187,7 +190,7 @@ file_size(file_ssize_t value, alignment align)
     const auto divisor = pow(1024, exp);
 
     if (align == alignment::none && divisor <= 1) {
-        return fmt::format(FMT_STRING("{}B"), value, UNITS[exp]);
+        return fmt::format(FMT_STRING("{}B"), value);
     }
     return fmt::format(FMT_STRING("{:.1f}{}B"),
                        divisor == 0 ? value : value / divisor,

src/base/lnav.gzip.cc

@@ -64,6 +64,7 @@ compress(const void* input, size_t len)
     }
     rc = deflate(&zs, Z_FINISH);
     if (rc != Z_STREAM_END) {
+        deflateEnd(&zs);
         return Err(fmt::format(FMT_STRING("unable to compress data -- {}"),
                                zError(rc)));
     }
@@ -113,17 +114,18 @@ uncompress(const std::string& src, const void* buffer, size_t size)
         }
     }
 
-    if (inflateEnd(&strm) != Z_OK) {
-        return Err(fmt::format(FMT_STRING("unable to uncompress: {} -- {}"),
-                               src,
-                               strm.msg ? strm.msg : zError(err)));
+    err = inflateEnd(&strm);
+    if (err != Z_OK) {
+        return Err(fmt::format(
+            FMT_STRING("unable to uncompress: {} -- {}"), src, zError(err)));
     }
 
     return Ok(std::move(uncomp.resize(strm.total_out)));
 }
 
 struct gunzip_producer : string_fragment_producer {
-    explicit gunzip_producer(const string_fragment& src, size_t uncompressed_size)
+    explicit gunzip_producer(const string_fragment& src,
+                             size_t uncompressed_size)
         : gp_src(src.to_string()), gp_uncompressed_size(uncompressed_size)
     {
     }

src/base/small_string_map.hh

@@ -43,7 +43,7 @@ struct small_string_map {
     char ssm_keys[MAP_SIZE * MAX_KEY_SIZE]{};
     uint32_t ssm_values[MAP_SIZE]{};
     uint32_t ssm_start_index{0};
-    bool ssm_age[MAP_SIZE];
+    bool ssm_age[MAP_SIZE]{};
 
     std::optional<uint32_t> lookup(const string_fragment& in);
     void insert(const string_fragment& key, uint32_t value);

src/base/string_util.cc

@@ -420,8 +420,8 @@ formatter<lnav::tainted_string>::format(const lnav::tainted_string& ts,
                                         format_context& ctx)
     -> decltype(ctx.out()) const
 {
-    auto esc_res = fmt::v10::detail::find_escape(&(*ts.ts_str.begin()),
-                                                 &(*ts.ts_str.end()));
+    auto esc_res = fmt::v10::detail::find_escape(
+        ts.ts_str.data(), ts.ts_str.data() + ts.ts_str.size());
     if (esc_res.end == nullptr) {
         return formatter<string_view>::format(ts.ts_str, ctx);
     }

src/sql.formatter.cc

@@ -146,7 +146,10 @@ end_close_scope(std::vector<std::string>& scope_stack)
     }
 
     scope_stack.pop_back();
-    return (scope_stack.back() == "CASE"_frag);
+    if (scope_stack.empty()) {
+        return false;
+    }
+    return scope_stack.back() == "CASE"_frag;
 }
 
 struct keyword_attrs {

test/test_ansi_scrubber.cc

@@ -76,6 +76,40 @@ main(int argc, char* argv[])
         assert(" Hello" == input);
     }
 
+    {
+        auto input = std::string("AB\x1b[33m\0CD", 10);
+        string_attrs_t sa;
+
+        scrub_ansi_string(input, &sa);
+        assert(input == "AB CD");
+    }
+
+    {
+        auto input = std::string("\x1b[33m\0Hello", 11);
+        string_attrs_t sa;
+
+        scrub_ansi_string(input, &sa);
+        assert(input == " Hello");
+    }
+
+    {
+        char input[] = "AB\x1b[33m\0CD";
+        auto sf = string_fragment{input, 0, 10};
+
+        auto new_len = erase_ansi_escapes(sf);
+        auto result = std::string(input, new_len);
+        assert(result == "AB CD");
+    }
+
+    {
+        char input[] = "\x1b[33m\0Hello";
+        auto sf = string_fragment{input, 0, 11};
+
+        auto new_len = erase_ansi_escapes(sf);
+        auto result = std::string(input, new_len);
+        assert(result == " Hello");
+    }
+
     {
         auto input = std::string("\x1b[0;1;38:2:1:2:3mHello");
         string_attrs_t sa;
@@ -91,6 +125,24 @@ main(int argc, char* argv[])
         assert(rgb->rc_b == 3);
     }
 
+    {
+        auto input = std::string("\x1b[0;48:2:10:20:30mHello");
+        string_attrs_t sa;
+
+        scrub_ansi_string(input, &sa);
+        assert(input == "Hello");
+        assert(sa.size() == 1);
+        assert(sa[0].sa_type == &VC_STYLE);
+        auto ta = sa[0].sa_value.get<text_attrs>();
+        auto rgb = std::get_if<rgb_color>(&ta.ta_bg_color.cu_value);
+        assert(rgb != nullptr);
+        assert(sa[0].sa_range.lr_start == 0);
+        assert(sa[0].sa_range.lr_end == -1);
+        assert(rgb->rc_r == 10);
+        assert(rgb->rc_g == 20);
+        assert(rgb->rc_b == 30);
+    }
+
     {
         auto input = std::string("\x1b[0;1;38:5:245mHello");
         string_attrs_t sa;