From b32e8f124b20d69adacc9d480f2c520ed477e60c Mon Sep 17 00:00:00 2001 From: Juhana Laurinharju Date: Sat, 2 Jul 2022 18:51:55 +0300 Subject: [PATCH 001/209] Add solarized_light theme --- themes/solarized_light.theme | 89 ++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 themes/solarized_light.theme diff --git a/themes/solarized_light.theme b/themes/solarized_light.theme new file mode 100644 index 0000000..9478410 --- /dev/null +++ b/themes/solarized_light.theme @@ -0,0 +1,89 @@ +#solarized_light theme +#modified from solarized_dark theme + +# Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" +# example for white: "#FFFFFF", "#ff" or "255 255 255". + +# All graphs and meters can be gradients +# For single color graphs leave "mid" and "end" variable empty. +# Use "start" and "end" variables for two color gradient +# Use "start", "mid" and "end" for three color gradient + +# Main background, empty for terminal default, need to be empty if you want transparent background +theme[main_bg]="#fdf6e3" + +# Main text color +theme[main_fg]="#586e75" + +# Title color for boxes +theme[title]="#002b36" + +# Higlight color for keyboard shortcuts +theme[hi_fg]="#b58900" + +# Background color of selected items +theme[selected_bg]="#eee8d5" + +# Foreground color of selected items +theme[selected_fg]="#b58900" + +# Color of inactive/disabled text +theme[inactive_fg]="#eee8d5" + +# Misc colors for processes box including mini cpu graphs, details memory graph and details status text +theme[proc_misc]="#d33682" + +# Cpu box outline color +theme[cpu_box]="#93a1a1" + +# Memory/disks box outline color +theme[mem_box]="#93a1a1" + +# Net up/down box outline color +theme[net_box]="#93a1a1" + +# Processes box outline color +theme[proc_box]="#93a1a1" + +# Box divider line and small boxes line color +theme[div_line]="#93a1a1" + +# Temperature graph colors +theme[temp_start]="#268bd2" +theme[temp_mid]="#ccb5f7" +theme[temp_end]="#fc5378" + +# CPU graph colors +theme[cpu_start]="#adc700" +theme[cpu_mid]="#d6a200" +theme[cpu_end]="#e65317" + +# Mem/Disk free meter +theme[free_start]="#4e5900" +theme[free_mid]="" +theme[free_end]="#bad600" + +# Mem/Disk cached meter +theme[cached_start]="#114061" +theme[cached_mid]="" +theme[cached_end]="#268bd2" + +# Mem/Disk available meter +theme[available_start]="#705500" +theme[available_mid]="" +theme[available_end]="#edb400" + +# Mem/Disk used meter +theme[used_start]="#6e1718" +theme[used_mid]="" +theme[used_end]="#e02f30" + +# Download graph colors +theme[download_start]="#3d4070" +theme[download_mid]="#6c71c4" +theme[download_end]="#a3a8f7" + +# Upload graph colors +theme[upload_start]="#701c45" +theme[upload_mid]="#d33682" +theme[upload_end]="#f56caf" From 09fb45b05feb5e0ddd7ec137fc4827ebf5730399 Mon Sep 17 00:00:00 2001 From: Dennis Mayr <30353238+dennismayr@users.noreply.github.com> Date: Fri, 22 Jul 2022 22:59:30 -0400 Subject: [PATCH 002/209] [feature] Created 'Elementarish' theme 'Elementarish' theme, based on Elementary OS' Terminal scheme. --- themes/elementarish.theme | 83 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 themes/elementarish.theme diff --git a/themes/elementarish.theme b/themes/elementarish.theme new file mode 100644 index 0000000..da92a55 --- /dev/null +++ b/themes/elementarish.theme @@ -0,0 +1,83 @@ +# Theme: Elementarish +# (inspired by Elementary OS) +# By: Dennis Mayr + +# Main bg +theme[main_bg]="#2b2b2b" + +# Main text color +theme[main_fg]="#a5a5a5" + +# Title color for boxes +theme[title]="#a5a5a5" + +# Higlight color for keyboard shortcuts +theme[hi_fg]="#dc322f" + +# Background color of selected item in processes box +theme[selected_bg]="#227dbc" + +# Foreground color of selected item in processes box +theme[selected_fg]="#a5a5a5" + +# Color of inactive/disabled text +theme[inactive_fg]="#586e75" + +# Misc colors for processes box including mini cpu graphs, details memory graph and details +status text +theme[proc_misc]="#227dbc" + +# Cpu box outline color +theme[cpu_box]="#586e75" + +# Memory/disks box outline color +theme[mem_box]="#586e75" + +# Net up/down box outline color +theme[net_box]="#586e75" + +# Processes box outline color +theme[proc_box]="#586e75" + +# Box divider line and small boxes line color +theme[div_line]="#586e75" + +# Temperature graph colors +theme[temp_start]="#859901" +theme[temp_mid]="#b58901" +theme[temp_end]="#dc322f" + +# CPU graph colors +theme[cpu_start]="#859901" +theme[cpu_mid]="#b58901" +theme[cpu_end]="#dc322f" + +# Mem/Disk free meter +theme[free_start]="#227dbc" +theme[free_mid]="#6c71c4" +theme[free_end]="#2a9d95" + +# Mem/Disk cached meter +theme[cached_start]="#227dbc" +theme[cached_mid]="#6c71c4" +theme[cached_end]="#dc322f" + +# Mem/Disk available meter +theme[available_start]="#227dbc" +theme[available_mid]="#6c71c4" +theme[available_end]="#dc322f" + +# Mem/Disk used meter +theme[used_start]="#859901" +theme[used_mid]="#b58901" +theme[used_end]="#dc322f" + +# Download graph colors +theme[download_start]="#227dbc" +theme[download_mid]="#6c71c4" +theme[download_end]="#dc322f" + +# Upload graph colors +theme[upload_start]="#227dbc" +theme[upload_mid]="#6c71c4" +theme[upload_end]="#dc322f" From 578e77607965e3d115e5d82d8964c8cfb2714622 Mon Sep 17 00:00:00 2001 From: Dennis Mayr <30353238+dennismayr@users.noreply.github.com> Date: Wed, 27 Jul 2022 15:16:44 -0400 Subject: [PATCH 003/209] [fix] Color correction Applied more accurate shades --- themes/elementarish.theme | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/themes/elementarish.theme b/themes/elementarish.theme index da92a55..8d5b9d1 100644 --- a/themes/elementarish.theme +++ b/themes/elementarish.theme @@ -6,26 +6,25 @@ theme[main_bg]="#2b2b2b" # Main text color -theme[main_fg]="#a5a5a5" +theme[main_fg]="#eee8d5" # Title color for boxes -theme[title]="#a5a5a5" +theme[title]="#eee8d5" # Higlight color for keyboard shortcuts theme[hi_fg]="#dc322f" # Background color of selected item in processes box -theme[selected_bg]="#227dbc" +theme[selected_bg]="#268bd2" # Foreground color of selected item in processes box -theme[selected_fg]="#a5a5a5" +theme[selected_fg]="#eee8d5" # Color of inactive/disabled text theme[inactive_fg]="#586e75" -# Misc colors for processes box including mini cpu graphs, details memory graph and details -status text -theme[proc_misc]="#227dbc" +# Misc colors for processes box including mini cpu graphs, details memory graph and details status text +theme[proc_misc]="#268bd2" # Cpu box outline color theme[cpu_box]="#586e75" @@ -43,41 +42,41 @@ theme[proc_box]="#586e75" theme[div_line]="#586e75" # Temperature graph colors -theme[temp_start]="#859901" +theme[temp_start]="#859900" theme[temp_mid]="#b58901" theme[temp_end]="#dc322f" # CPU graph colors -theme[cpu_start]="#859901" +theme[cpu_start]="#859900" theme[cpu_mid]="#b58901" theme[cpu_end]="#dc322f" # Mem/Disk free meter -theme[free_start]="#227dbc" +theme[free_start]="#268bd2" theme[free_mid]="#6c71c4" theme[free_end]="#2a9d95" # Mem/Disk cached meter -theme[cached_start]="#227dbc" +theme[cached_start]="#268bd2" theme[cached_mid]="#6c71c4" theme[cached_end]="#dc322f" # Mem/Disk available meter -theme[available_start]="#227dbc" +theme[available_start]="#268bd2" theme[available_mid]="#6c71c4" theme[available_end]="#dc322f" # Mem/Disk used meter -theme[used_start]="#859901" +theme[used_start]="#859900" theme[used_mid]="#b58901" theme[used_end]="#dc322f" # Download graph colors -theme[download_start]="#227dbc" +theme[download_start]="#268bd2" theme[download_mid]="#6c71c4" theme[download_end]="#dc322f" # Upload graph colors -theme[upload_start]="#227dbc" +theme[upload_start]="#268bd2" theme[upload_mid]="#6c71c4" theme[upload_end]="#dc322f" From 67339cf9549ecb20e6c8b3eabaa660dc5600460d Mon Sep 17 00:00:00 2001 From: Jonathan Wright Date: Thu, 28 Jul 2022 09:26:03 -0500 Subject: [PATCH 004/209] Add Fedora/RHEL install docs --- README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/README.md b/README.md index 3520962..6563be3 100644 --- a/README.md +++ b/README.md @@ -274,6 +274,15 @@ Also needs a UTF8 locale and a font that covers: sudo zypper in btop ``` * For all other versions, see [openSUSE Software: btop](https://software.opensuse.org/package/btop) +* **Fedora** + ```bash + sudo dnf install btop + ``` +* **RHEL/AlmaLinux 8+** + ```bash + sudo dnf install epel-release + sudo dnf install btop + ``` **Binary release on Homebrew (macOS (x86_64 & ARM64) / Linux (x86_64))** From c0c57818ce1a118a269c5b99b9aab61ce443a01e Mon Sep 17 00:00:00 2001 From: kyli0x Date: Thu, 11 Aug 2022 13:40:47 -0400 Subject: [PATCH 005/209] updated color change --- themes/kyli0x.theme | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/themes/kyli0x.theme b/themes/kyli0x.theme index 5f5be3c..c25790e 100644 --- a/themes/kyli0x.theme +++ b/themes/kyli0x.theme @@ -2,13 +2,13 @@ #by Kyli0x # Main background, empty for terminal default, need to be empty if you want transparent background -theme[main_bg]="#23252e" +theme[main_bg]="#222222" # Main text color -theme[main_fg]="#f8f8f2" +theme[main_fg]="#e8f6f5" # Title color for boxes -theme[title]="#f8f8f2" +theme[title]="#e8f6f5" # Highlight color for keyboard shortcuts theme[hi_fg]="#21d6c9" @@ -17,16 +17,16 @@ theme[hi_fg]="#21d6c9" theme[selected_bg]="#1aaba0" # Foreground color of selected item in processes box -theme[selected_fg]="#f8f8f2" +theme[selected_fg]="#e8f6f5" # Color of inactive/disabled text -theme[inactive_fg]="#497e7a" +theme[inactive_fg]="#5ec4bc" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling -theme[graph_text]="#21d6c9" +theme[graph_text]="ba1a84" # Background color of the percentage meters -theme[meter_bg]="#80638e" +theme[meter_bg]="#5ec4bc" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#21d6c9" @@ -49,44 +49,44 @@ theme[div_line]="#80638e" # Temperature graph colors theme[temp_start]="#21d6c9" theme[temp_mid]="#1aaba0" -theme[temp_end]="#497e7a" +theme[temp_end]="#5ec4bc" # CPU graph colors theme[cpu_start]="#21d6c9" theme[cpu_mid]="#1aaba0" -theme[cpu_end]="#497e7a" +theme[cpu_end]="#5ec4bc" # Mem/Disk free meter theme[free_start]="#21d6c9" theme[free_mid]="#1aaba0" -theme[free_end]="#497e7a" +theme[free_end]="#5ec4bc" # Mem/Disk cached meter theme[cached_start]="#21d6c9" theme[cached_mid]="#1aaba0" -theme[cached_end]="#497e7a" +theme[cached_end]="#5ec4bc" # Mem/Disk available meter theme[available_start]="#21d6c9" theme[available_mid]="#1aaba0" -theme[available_end]="#497e7a" +theme[available_end]="#5ec4bc" # Mem/Disk used meter theme[used_start]="#21d6c9" theme[used_mid]="#1aaba0" -theme[used_end]="#497e7a" +theme[used_end]="#5ec4bc" # Download graph colors theme[download_start]="#21d6c9" theme[download_mid]="#1aaba0" -theme[download_end]="#497e7a" +theme[download_end]="#5ec4bc" # Upload graph colors theme[upload_start]="#ec95ec" theme[upload_mid]="#1aaba0" -theme[upload_end]="#497e7a" +theme[upload_end]="#5ec4bc" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#21d6c9" theme[process_mid]="#1aaba0" -theme[process_end]="#d486d4" +theme[process_end]="#ba1a84" From a734d51288542ed533f135cd3b5518c3b7ccca10 Mon Sep 17 00:00:00 2001 From: pkubaj Date: Tue, 23 Aug 2022 02:27:21 +0000 Subject: [PATCH 006/209] Add FreeBSD installation command --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 6563be3..14a880d 100644 --- a/README.md +++ b/README.md @@ -283,6 +283,10 @@ Also needs a UTF8 locale and a font that covers: sudo dnf install epel-release sudo dnf install btop ``` +* **FreeBSD** + ```sh + pkg install btop + ``` **Binary release on Homebrew (macOS (x86_64 & ARM64) / Linux (x86_64))** From 90034156dd49ca4a330dc66a8fc82d5e241ea2f9 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 28 Aug 2022 13:36:00 +0200 Subject: [PATCH 007/209] Fixed: Memory values not clearing properly when not in graph mode in mem box --- src/btop_draw.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 3603406..780c6c1 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -637,7 +637,7 @@ namespace Cpu { if (b_column_size > 0 or extra_width > 0) out += Theme::c("inactive_fg") + graph_bg * (5 * b_column_size + extra_width) + Mv::l(5 * b_column_size + extra_width) + core_graphs.at(n)(cpu.core_percent.at(n), data_same or redraw); - + out += Theme::g("cpu").at(clamp(cpu.core_percent.at(n).back(), 0ll, 100ll)); out += rjust(to_string(cpu.core_percent.at(n).back()), (b_column_size < 2 ? 3 : 4)) + Theme::c("main_fg") + '%'; @@ -824,10 +824,11 @@ namespace Mem { if (title.empty()) title = capitalize(name); const string humanized = floating_humanizer(mem.stats.at(name)); + const int offset = max(0, divider.empty() ? 9 - (int)humanized.size() : 0); const string graphics = (use_graphs ? mem_graphs.at(name)(mem.percent.at(name), redraw or data_same) : mem_meters.at(name)(mem.percent.at(name).back())); if (mem_size > 2) { out += Mv::to(y+1+cy, x+1+cx) + divider + title.substr(0, big_mem ? 10 : 5) + ":" - + Mv::to(y+1+cy, x+cx + mem_width - 2 - humanized.size()) + trans(humanized) + + Mv::to(y+1+cy, x+cx + mem_width - 2 - humanized.size()) + (divider.empty() ? Mv::l(offset) + string(" ") * offset + humanized : trans(humanized)) + Mv::to(y+2+cy, x+cx + (graph_height >= 2 ? 0 : 1)) + graphics + up + rjust(to_string(mem.percent.at(name).back()) + "%", 4); cy += (graph_height == 0 ? 2 : graph_height + 1); } From 0c6a2f701d74cea7f5a4e2b59a10186920eb0733 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 28 Aug 2022 13:47:37 +0200 Subject: [PATCH 008/209] v1.2.9 Bug fixes + new features and themes --- CHANGELOG.md | 22 ++++++++++++++++++++++ src/btop.cpp | 2 +- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index dacbb53..e0e8760 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,25 @@ +## v1.2.9 + +* Fixed: Memory values not clearing properly when not in graph mode in mem box + +* Changed: kyli0x theme color update, by @kyli0x + +* Added: Elementarish theme, by @dennismayr + +* Added: key "?" to see help, by @mohi001 + +* Added: solarized_light theme, by @Fingerzam + +* Changed: Made ZFS stats collection compatible with zfs_pools_only option, by @simplepad + +* Changed: Rewrite of process sorting and tree generation including fixes for tree sorting and mouse support + +* Added: Option to hide the small cpu graphs for processes + +* Changed: Small graphs now show colors for each character + +* Fixed: Getting selfpath on macos (fix for finding theme folder) + ## v1.2.8 * Added: Support for ZFS pool io stats monitoring, by @simplepad diff --git a/src/btop.cpp b/src/btop.cpp index 484a0df..5aff90c 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -62,7 +62,7 @@ namespace Global { {"#801414", "██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ╚═╝"}, {"#000000", "╚═════╝ ╚═╝ ╚═════╝ ╚═╝"}, }; - const string Version = "1.2.8"; + const string Version = "1.2.9"; int coreCount; string overlay; From 26ac007777c574bf2f5648da4e677403b964886f Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 28 Aug 2022 14:22:36 +0200 Subject: [PATCH 009/209] Fixed: Process tree filtering not case insensitive --- src/btop_shared.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/btop_shared.cpp b/src/btop_shared.cpp index 606c082..d7856e8 100644 --- a/src/btop_shared.cpp +++ b/src/btop_shared.cpp @@ -106,9 +106,9 @@ namespace Proc { //? If filtering, include children of matching processes if (not found and (should_filter or not filter.empty())) { if (not s_contains(std::to_string(cur_proc.pid), filter) - and not s_contains(cur_proc.name, filter) - and not s_contains(cur_proc.cmd, filter) - and not s_contains(cur_proc.user, filter)) { + and not s_contains_ic(cur_proc.name, filter) + and not s_contains_ic(cur_proc.cmd, filter) + and not s_contains_ic(cur_proc.user, filter)) { filtering = true; cur_proc.filtered = true; filter_found++; From b9f1af6b1f97150a37d141368a51e3bd9d94d0ac Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 28 Aug 2022 20:38:47 +0200 Subject: [PATCH 010/209] Update README.md --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 50345d1..e84c13d 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,12 @@ ## News +##### 28 August 2022 + +[![btop4win](https://github.com/aristocratos/btop4win/raw/master/Img/logo.png)](https://github.com/aristocratos/btop4win) + +First release of btop4win available at https://github.com/aristocratos/btop4win + ##### 16 January 2022 Release v1.2.0 with FreeBSD support. No release binaries for FreeBSD provided as of yet. From a1572e07e6da94ef5594c24bee73e9503c83ce14 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Wed, 31 Aug 2022 09:27:02 +0200 Subject: [PATCH 011/209] Update FUNDING.yml --- .github/FUNDING.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml index 45d2a03..fb482fd 100644 --- a/.github/FUNDING.yml +++ b/.github/FUNDING.yml @@ -3,7 +3,7 @@ github: aristocratos patreon: # Replace with a single Patreon username open_collective: # Replace with a single Open Collective username -ko_fi: # Replace with a single Ko-fi username +ko_fi: aristocratos tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry liberapay: # Replace with a single Liberapay username From ee0945969d46c17a291142b600173a11068e390d Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Wed, 31 Aug 2022 09:29:16 +0200 Subject: [PATCH 012/209] Update FUNDING.yml --- .github/FUNDING.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml index fb482fd..ba33216 100644 --- a/.github/FUNDING.yml +++ b/.github/FUNDING.yml @@ -9,4 +9,4 @@ community_bridge: # Replace with a single Community Bridge project-name e.g., cl liberapay: # Replace with a single Liberapay username issuehunt: # Replace with a single IssueHunt username otechie: # Replace with a single Otechie username -custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] +custom: https://paypal.me/aristocratos From 5ff908119727095b688eee6ce92d2976a2e28f7a Mon Sep 17 00:00:00 2001 From: Samuel Sinclair Date: Sat, 17 Sep 2022 12:51:22 +0800 Subject: [PATCH 013/209] [feature] Added Paper theme --- themes/paper.theme | 83 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 themes/paper.theme diff --git a/themes/paper.theme b/themes/paper.theme new file mode 100644 index 0000000..111289d --- /dev/null +++ b/themes/paper.theme @@ -0,0 +1,83 @@ +# Bashtop Paper theme +# c/o @s6muel +# inspired by @yorickpeterse's vim-paper theme at https://gitlab.com/yorickpeterse/vim-paper +# + +# Main background, empty for terminal default, need to be empty if you want transparent background +theme[main_bg]="#F2EEDE" + +# Main text color +theme[main_fg]="#00" + +# Title color for boxes +theme[title]="#00" + +# Higlight color for keyboard shortcuts +theme[hi_fg]="#CC3E28" + +# Background color of selected item in processes box +theme[selected_bg]="#D8D5C7" + +# Foreground color of selected item in processes box +theme[selected_fg]="#00" + +# Color of inactive/disabled text +theme[inactive_fg]="#d8d5c7" + +# Misc colors for processes box including mini cpu graphs, details memory graph and details status text +theme[proc_misc]="#00" + +# Cpu box outline color +theme[cpu_box]="#00" + +# Memory/disks box outline color +theme[mem_box]="#00" + +# Net up/down box outline color +theme[net_box]="#00" + +# Processes box outline color +theme[proc_box]="#00" + +# Box divider line and small boxes line color +theme[div_line]="#00" + +# Temperature graph colors +theme[temp_start]="#55" +theme[temp_mid]="#00" +theme[temp_end]="#CC3E28" + +# CPU graph colors +theme[cpu_start]="#55" +theme[cpu_mid]="#00" +theme[cpu_end]="#CC3E28" + +# Mem/Disk free meter +theme[free_start]="#216609" +theme[free_mid]="" +theme[free_end]="#216609" + +# Mem/Disk cached meter +theme[cached_start]="#1e6fcc" +theme[cached_mid]="" +theme[cached_end]="#1e6fcc" + +# Mem/Disk available meter +theme[available_start]="#216609" +theme[available_mid]="" +theme[available_end]="#216609" + +# Mem/Disk used meter +theme[used_start]="#CC3E28" +theme[used_mid]="" +theme[used_end]="#CC3E28" + +# Download graph colors +theme[download_start]="#55" +theme[download_mid]="#00" +theme[download_end]="#CC3E28" + +# Upload graph colors +theme[upload_start]="#55" +theme[upload_mid]="#00" +theme[upload_end]="#CC3E28" From f2db8dbbb64eff6b7a94effa1a0f9c7ec785963b Mon Sep 17 00:00:00 2001 From: Franciosi Date: Tue, 27 Sep 2022 18:55:28 -0300 Subject: [PATCH 014/209] Updated README.md s/OSX/macOS and small text improves --- README.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index e84c13d..4fc8ff3 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ ![Linux](https://img.shields.io/badge/-Linux-grey?logo=linux) -![OSX](https://img.shields.io/badge/-OSX-black?logo=apple) +![macOS](https://img.shields.io/badge/-OSX-black?logo=apple) ![FreeBSD](https://img.shields.io/badge/-FreeBSD-red?logo=freebsd) ![Usage](https://img.shields.io/badge/Usage-System%20resource%20monitor-yellow) ![c++20](https://img.shields.io/badge/cpp-c%2B%2B20-green) @@ -15,7 +15,7 @@ [![Coffee](https://img.shields.io/badge/-Buy%20me%20a%20Coffee-grey?logo=Ko-fi)](https://ko-fi.com/aristocratos) [![btop](https://snapcraft.io/btop/badge.svg)](https://snapcraft.io/btop) [![Continuous Build Linux](https://github.com/aristocratos/btop/actions/workflows/continuous-build-linux.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-linux.yml) -[![Continuous Build MacOS](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) +[![Continuous Build macOS](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) ## Index @@ -28,9 +28,9 @@ * [Prerequisites](#prerequisites) (Read this if you are having issues!) * [Screenshots](#screenshots) * [Keybindings](#help-menu) -* [Installation Linux/OSX](#installation) +* [Installation Linux/macOS](#installation) * [Compilation Linux](#compilation-linux) -* [Compilation OSX](#compilation-osx) +* [Compilation macOS](#compilation-macos-osx) * [Compilation FreeBSD](#compilation-freebsd) * [Installing the snap](#installing-the-snap) * [Configurability](#configurability) @@ -50,12 +50,12 @@ Release v1.2.0 with FreeBSD support. No release binaries for FreeBSD provided as Again a big thanks to [@joske](https://github.com/joske) for his porting efforts! -Since compatibility with Linux, MacOS and FreeBSD are done, the focus going forward will be on new features like GPU monitoring. +Since compatibility with Linux, macOS and FreeBSD are done, the focus going forward will be on new features like GPU monitoring. ##### 13 November 2021 -Release v1.1.0 with OSX support. Binaries in [continuous-build-macos](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) are only x86 for now. -Macos binaries + installer are included for both x86 and ARM64 (Apple Silicon) in the releases. +Release v1.1.0 with macOS support. Binaries in [continuous-build-macos](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) are only x86 for now. +macOS binaries + installer are included for both x86 and ARM64 (Apple Silicon) in the releases. Big thank you to [@joske](https://github.com/joske) who wrote the vast majority of the implementation! @@ -64,12 +64,12 @@ Big thank you to [@joske](https://github.com/joske) who wrote the vast majority ##### 30 October 2021 -Work on the OSX and FreeBSD branches, both initiated and mostly worked on by [@joske](https://github.com/joske), will likely be completed in the coming weeks. -The OSX branch has some memory leaks that needs to be sorted out and both have some issues with the processes cpu usage calculation and other smaller issues that needs fixing. +Work on the OSX [macOS] and FreeBSD branches, both initiated and mostly worked on by [@joske](https://github.com/joske), will likely be completed in the coming weeks. +The OSX [macOS] branch has some memory leaks that needs to be sorted out and both have some issues with the processes cpu usage calculation and other smaller issues that needs fixing. If you want to help out, test for bugs/fix bugs or just try out the branches: -**OSX** +**macOS / OSX** ```bash # Install and use Homebrew or MacPorts package managers for easy dependency installation brew install coreutils make gcc@11 @@ -88,12 +88,12 @@ git checkout freebsd gmake ``` -Note that GNU make (`gmake`) is recommended but not required for OSX but it is required on FreeBSD. +Note that GNU make (`gmake`) is recommended but not required for macOS/OSX but it is required on FreeBSD. ##### 6 October 2021 -OsX development have been started by [@joske](https://github.com/joske), big thanks :) +macOS development have been started by [@joske](https://github.com/joske), big thanks :) See branch [OSX](https://github.com/aristocratos/btop/tree/OSX) for current progress. ##### 18 September 2021 @@ -108,7 +108,7 @@ Please report any bugs to the [Issues](https://github.com/aristocratos/btop/issu The development plan right now: -* 1.1.0 Mac OsX support +* 1.1.0 macOS [OSX] support * 1.2.0 FreeBSD support * 1.3.0 Support for GPU monitoring * 1.X.0 Other platforms and features... @@ -118,7 +118,7 @@ Windows support is not in the plans as of now, but if anyone else wants to take ##### 5 May 2021 This project is gonna take some time until it has complete feature parity with bpytop, since all system information gathering will have to be written from scratch without any external libraries. -And will need some help in the form of code contributions to get complete support for BSD and OSX. +And will need some help in the form of code contributions to get complete support for BSD and macOS/OSX. @@ -148,9 +148,9 @@ C++ version and continuation of [bashtop](https://github.com/aristocratos/bashto * Send any signal to selected process. * UI menu for changing all config file options. * Auto scaling graph for network usage. -* Shows IO activity and speeds for disks +* Shows IO activity and speeds for disks. * Battery meter -* Selectable symbols for the graphs +* Selectable symbols for the graphs. * Custom presets * And more... @@ -394,7 +394,7 @@ Also needs a UTF8 locale and a font that covers: make help ``` -## Compilation OSX +## Compilation macOS OSX Needs GCC 10 or higher, (GCC 11 or above strongly recommended for better CPU efficiency in the compiled binary). From 3796a8ccee82b33ee1439967cc87e83d78463f88 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 2 Oct 2022 13:20:15 +0200 Subject: [PATCH 015/209] Fixed: Extra checks to avoid crash on trying to replace empty strings in tree mode --- src/btop_shared.cpp | 7 +++---- src/linux/btop_collect.cpp | 4 ++-- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/btop_shared.cpp b/src/btop_shared.cpp index d7856e8..94806d5 100644 --- a/src/btop_shared.cpp +++ b/src/btop_shared.cpp @@ -140,12 +140,10 @@ namespace Proc { } //? Recursive iteration over all children - int children = 0; for (auto& p : rng::equal_range(in_procs, cur_proc.pid, rng::less{}, &proc_info::ppid)) { if (collapsed and not filtering) { cur_proc.filtered = true; } - children++; _tree_gen(p, in_procs, out_procs.back().children, cur_depth + 1, (collapsed or cur_proc.collapsed), filter, found, no_update, should_filter); @@ -164,11 +162,12 @@ namespace Proc { } //? Add tree terminator symbol if it's the last child in a sub-tree - if (children > 0 and out_procs.back().children.back().entry.get().prefix.size() >= 8 and not out_procs.back().children.back().entry.get().prefix.ends_with("]─")) + if (out_procs.back().children.size() > 0 and out_procs.back().children.back().entry.get().prefix.size() >= 8 and not out_procs.back().children.back().entry.get().prefix.ends_with("]─")) out_procs.back().children.back().entry.get().prefix.replace(out_procs.back().children.back().entry.get().prefix.size() - 8, 8, " └─ "); //? Add collapse/expand symbols if process have any children - out_procs.at(cur_pos).entry.get().prefix = " │ "s * cur_depth + (children > 0 ? (cur_proc.collapsed ? "[+]─" : "[-]─") : " ├─ "); + out_procs.at(cur_pos).entry.get().prefix = " │ "s * cur_depth + (out_procs.at(cur_pos).children.size() > 0 ? (cur_proc.collapsed ? "[+]─" : "[-]─") : " ├─ "); + } } \ No newline at end of file diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 86514a9..e986d35 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -1907,11 +1907,11 @@ namespace Proc { tree_sort(tree_procs, sorting, reverse, index, current_procs.size()); //? Add tree begin symbol to first item if childless - if (tree_procs.front().children.empty()) + if (tree_procs.size() > 0 and tree_procs.front().children.empty() and tree_procs.front().entry.get().prefix.size() >= 8) tree_procs.front().entry.get().prefix.replace(tree_procs.front().entry.get().prefix.size() - 8, 8, " ┌─ "); //? Add tree terminator symbol to last item if childless - if (tree_procs.back().children.empty()) + if (tree_procs.size() > 0 and tree_procs.back().children.empty() and tree_procs.back().entry.get().prefix.size() >= 8) tree_procs.back().entry.get().prefix.replace(tree_procs.back().entry.get().prefix.size() - 8, 8, " └─ "); //? Final sort based on tree index From bfbb12993753b1f0ff41d37be84017e3a7110d2c Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 2 Oct 2022 13:47:55 +0200 Subject: [PATCH 016/209] Fixed missing "#" from value --- themes/kyli0x.theme | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/themes/kyli0x.theme b/themes/kyli0x.theme index c25790e..c955287 100644 --- a/themes/kyli0x.theme +++ b/themes/kyli0x.theme @@ -23,7 +23,7 @@ theme[selected_fg]="#e8f6f5" theme[inactive_fg]="#5ec4bc" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling -theme[graph_text]="ba1a84" +theme[graph_text]="#ba1a84" # Background color of the percentage meters theme[meter_bg]="#5ec4bc" From bc9b803189872c0f271d22a5f25c8fd6294cc152 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Sun, 2 Oct 2022 15:40:08 +0300 Subject: [PATCH 017/209] Ignore files created by Qt Creator --- .gitignore | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index fc1994b..25ee477 100644 --- a/.gitignore +++ b/.gitignore @@ -53,4 +53,14 @@ btop #do not ignore .github directory -!.github \ No newline at end of file +!.github + +# Ignore files created by Qt Creator +*.config +*.creator +*.creator.user +*.creator.user.* +*.cflags +*.cxxflags +*.files +*.includes From 24f06094f8e573e0c85f01b989bd5e9313114edf Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 2 Oct 2022 15:25:10 +0200 Subject: [PATCH 018/209] Fixed: Crashing when cores are offline --- src/linux/btop_collect.cpp | 110 ++++++++++++++++++++++--------------- 1 file changed, 66 insertions(+), 44 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index e986d35..ecbc7bd 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -653,68 +653,90 @@ namespace Cpu { cread.close(); //? Get cpu total times for all cores from /proc/stat + string cpu_name; cread.open(Shared::procPath / "stat"); - for (int i = 0; cread.good() and cread.peek() == 'c'; i++) { - cread.ignore(SSmax, ' '); + int i = 0; + for (; i <= Shared::coreCount; i++) { - //? Expected on kernel 2.6.3> : 0=user, 1=nice, 2=system, 3=idle, 4=iowait, 5=irq, 6=softirq, 7=steal, 8=guest, 9=guest_nice - vector times; - long long total_sum = 0; - - for (uint64_t val; cread >> val; total_sum += val) { - times.push_back(val); + //? Make sure to add zero value for missing core values if at end of file + if ((not cread.good() or cread.peek() != 'c') and i < Shared::coreCount) { + if (i == 0) throw std::runtime_error("Failed to parse /proc/stat"); + else cpu.core_percent.at(i-1).push_back(0); } - cread.clear(); - if (times.size() < 4) throw std::runtime_error("Malformatted /proc/stat"); + else { + if (i == 0) cread.ignore(SSmax, ' '); + else { + cread >> cpu_name; + int cpuNum = std::stoi(cpu_name.substr(3)); + if (cpuNum > Shared::coreCount - 1) throw std::runtime_error("Mismatch betweeen /proc/stat core count and previously detected core count"); + //? Add zero value for core if core number is missing from /proc/stat + while (i - 1 < cpuNum) { + cpu.core_percent.at(i-1).push_back(0); + if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); + i++; + } + } - //? Subtract fields 8-9 and any future unknown fields - const long long totals = max(0ll, total_sum - (times.size() > 8 ? std::accumulate(times.begin() + 8, times.end(), 0) : 0)); + //? Expected on kernel 2.6.3> : 0=user, 1=nice, 2=system, 3=idle, 4=iowait, 5=irq, 6=softirq, 7=steal, 8=guest, 9=guest_nice + vector times; + long long total_sum = 0; - //? Add iowait field if present - const long long idles = max(0ll, times.at(3) + (times.size() > 4 ? times.at(4) : 0)); + for (uint64_t val; cread >> val; total_sum += val) { + times.push_back(val); + } + cread.clear(); + if (times.size() < 4) throw std::runtime_error("Malformatted /proc/stat"); - //? Calculate values for totals from first line of stat - if (i == 0) { - const long long calc_totals = max(1ll, totals - cpu_old.at("totals")); - const long long calc_idles = max(1ll, idles - cpu_old.at("idles")); - cpu_old.at("totals") = totals; - cpu_old.at("idles") = idles; + //? Subtract fields 8-9 and any future unknown fields + const long long totals = max(0ll, total_sum - (times.size() > 8 ? std::accumulate(times.begin() + 8, times.end(), 0) : 0)); - //? Total usage of cpu - cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); + //? Add iowait field if present + const long long idles = max(0ll, times.at(3) + (times.size() > 4 ? times.at(4) : 0)); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); + //? Calculate values for totals from first line of stat + if (i == 0) { + const long long calc_totals = max(1ll, totals - cpu_old.at("totals")); + const long long calc_idles = max(1ll, idles - cpu_old.at("idles")); + cpu_old.at("totals") = totals; + cpu_old.at("idles") = idles; - //? Populate cpu.cpu_percent with all fields from stat - for (int ii = 0; const auto& val : times) { - cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); - cpu_old.at(time_names.at(ii)) = val; + //? Total usage of cpu + cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph - while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); + while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); - if (++ii == 10) break; + //? Populate cpu.cpu_percent with all fields from stat + for (int ii = 0; const auto& val : times) { + cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); + cpu_old.at(time_names.at(ii)) = val; + + //? Reduce size if there are more values than needed for graph + while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); + + if (++ii == 10) break; + } + continue; + } + //? Calculate cpu total for each core + else { + if (i > Shared::coreCount) break; + const long long calc_totals = max(0ll, totals - core_old_totals.at(i-1)); + const long long calc_idles = max(0ll, idles - core_old_idles.at(i-1)); + core_old_totals.at(i-1) = totals; + core_old_idles.at(i-1) = idles; + + cpu.core_percent.at(i-1).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); } } - //? Calculate cpu total for each core - else { - if (i > Shared::coreCount) break; - const long long calc_totals = max(0ll, totals - core_old_totals.at(i-1)); - const long long calc_idles = max(0ll, idles - core_old_idles.at(i-1)); - core_old_totals.at(i-1) = totals; - core_old_idles.at(i-1) = idles; - cpu.core_percent.at(i-1).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); - - //? Reduce size if there are more values than needed for graph - if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); - - } + //? Reduce size if there are more values than needed for graph + if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); } + + if (i < Shared::coreCount + 1) throw std::runtime_error("Failed to parse /proc/stat"); } catch (const std::exception& e) { - Logger::debug("get_cpuHz() : " + (string)e.what()); if (cread.bad()) throw std::runtime_error("Failed to read /proc/stat"); else throw std::runtime_error("collect() : " + (string)e.what()); } From 478a44cc5723beadc11ff362b745b0ff1df704f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Sun, 2 Oct 2022 18:52:18 +0300 Subject: [PATCH 019/209] Clean up btop_tools.{hpp,cpp} files --- src/btop_tools.cpp | 41 ++++++++++++++++++++++++++++------------- src/btop_tools.hpp | 36 +++++++++++++++++++++++------------- 2 files changed, 51 insertions(+), 26 deletions(-) diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 301e554..dd09696 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -35,7 +35,15 @@ tab-size = 4 #include #include -using std::string_view, std::max, std::floor, std::to_string, std::cin, std::cout, std::flush, robin_hood::unordered_flat_map; +using std::cin; +using std::cout; +using std::floor; +using std::flush; +using std::max; +using std::string_view; +using std::to_string; +using robin_hood::unordered_flat_map; + namespace fs = std::filesystem; namespace rng = std::ranges; @@ -44,9 +52,9 @@ namespace rng = std::ranges; //* Collection of escape codes and functions for terminal manipulation namespace Term { - atomic initialized = false; - atomic width = 0; - atomic height = 0; + atomic initialized{}; // defaults to false + atomic width{}; // defaults to 0 + atomic height{}; // defaults to 0 string current_tty; namespace { @@ -110,7 +118,7 @@ namespace Term { initialized = (bool)isatty(STDIN_FILENO); if (initialized) { tcgetattr(STDIN_FILENO, &initial_settings); - current_tty = (ttyname(STDIN_FILENO) != NULL ? (string)ttyname(STDIN_FILENO) : "unknown"); + current_tty = (ttyname(STDIN_FILENO) != NULL ? static_cast(ttyname(STDIN_FILENO)) : "unknown"); //? Disable stream sync cin.sync_with_stdio(false); @@ -253,14 +261,18 @@ namespace Tools { string ltrim(const string& str, const string& t_str) { string_view str_v = str; - while (str_v.starts_with(t_str)) str_v.remove_prefix(t_str.size()); - return (string)str_v; + while (str_v.starts_with(t_str)) + str_v.remove_prefix(t_str.size()); + + return string{str_v}; } string rtrim(const string& str, const string& t_str) { string_view str_v = str; - while (str_v.ends_with(t_str)) str_v.remove_suffix(t_str.size()); - return (string)str_v; + while (str_v.ends_with(t_str)) + str_v.remove_suffix(t_str.size()); + + return string{str_v}; } auto ssplit(const string& str, const char& delim) -> vector { @@ -318,7 +330,7 @@ namespace Tools { newstr.append(Mv::r(x)); oldstr.remove_prefix(pos + x); } - return (newstr.empty()) ? str : newstr + (string)oldstr; + return (newstr.empty()) ? str : newstr + string{oldstr}; } string sec_to_dhms(size_t seconds, bool no_days, bool no_seconds) { @@ -447,7 +459,7 @@ namespace Tools { string hostname() { char host[HOST_NAME_MAX]; gethostname(host, HOST_NAME_MAX); - return (string)host; + return string{host}; } string username() { @@ -497,14 +509,17 @@ namespace Logger { } if (not ec) { std::ofstream lwrite(logfile, std::ios::app); - if (first) { first = false; lwrite << "\n" << strf_time(tdf) << "===> btop++ v." << Global::Version << "\n";} + if (first) { + first = false; + lwrite << "\n" << strf_time(tdf) << "===> btop++ v." << Global::Version << "\n"; + } lwrite << strf_time(tdf) << log_levels.at(level) << ": " << msg << "\n"; } else logfile.clear(); } catch (const std::exception& e) { logfile.clear(); - throw std::runtime_error("Exception in Logger::log_write() : " + (string)e.what()); + throw std::runtime_error("Exception in Logger::log_write() : " + string{e.what()}); } } } diff --git a/src/btop_tools.hpp b/src/btop_tools.hpp index 862981a..c4d4279 100644 --- a/src/btop_tools.hpp +++ b/src/btop_tools.hpp @@ -18,16 +18,17 @@ tab-size = 4 #pragma once -#include -#include +#include // for std::ranges::count_if #include #include -#include +#include #include #include -#include +#include +#include #include #include +#include #include #include #ifndef HOST_NAME_MAX @@ -38,7 +39,12 @@ tab-size = 4 #endif #endif -using std::string, std::vector, std::atomic, std::to_string, std::tuple, std::array; +using std::array; +using std::atomic; +using std::string; +using std::to_string; +using std::tuple; +using std::vector; //? ------------------------------------------------- NAMESPACES ------------------------------------------------------ @@ -80,19 +86,19 @@ namespace Fx { //* Collection of escape codes and functions for cursor manipulation namespace Mv { //* Move cursor to , - inline string to(const int& line, const int& col) { return Fx::e + to_string(line) + ';' + to_string(col) + 'f'; } + inline string to(int line, int col) { return Fx::e + to_string(line) + ';' + to_string(col) + 'f'; } //* Move cursor right columns - inline string r(const int& x) { return Fx::e + to_string(x) + 'C'; } + inline string r(int x) { return Fx::e + to_string(x) + 'C'; } //* Move cursor left columns - inline string l(const int& x) { return Fx::e + to_string(x) + 'D'; } + inline string l(int x) { return Fx::e + to_string(x) + 'D'; } //* Move cursor up x lines - inline string u(const int& x) { return Fx::e + to_string(x) + 'A'; } + inline string u(int x) { return Fx::e + to_string(x) + 'A'; } //* Move cursor down x lines - inline string d(const int& x) { return Fx::e + to_string(x) + 'B'; } + inline string d(int x) { return Fx::e + to_string(x) + 'B'; } //* Save cursor position const string save = Fx::e + "s"; @@ -254,10 +260,14 @@ namespace Tools { auto ssplit(const string& str, const char& delim = ' ') -> vector; //* Put current thread to sleep for milliseconds - inline void sleep_ms(const size_t& ms) { std::this_thread::sleep_for(std::chrono::milliseconds(ms)); } + inline void sleep_ms(const size_t& ms) { + std::this_thread::sleep_for(std::chrono::milliseconds(ms)); + } //* Put current thread to sleep for microseconds - inline void sleep_micros(const size_t& micros) { std::this_thread::sleep_for(std::chrono::microseconds(micros)); } + inline void sleep_micros(const size_t& micros) { + std::this_thread::sleep_for(std::chrono::microseconds(micros)); + } //* Left justify string if is greater than length, limit return size to by default string ljust(string str, const size_t x, const bool utf=false, const bool wide=false, const bool limit=true); @@ -308,7 +318,7 @@ namespace Tools { //* Sets atomic to true on construct, sets to false on destruct class atomic_lock { atomic& atom; - bool not_true = false; + bool not_true{}; // defaults to false public: atomic_lock(atomic& atom, bool wait=false); ~atomic_lock(); From dfa2a9b9209b20381e1a2a102ec296caf1765978 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Sun, 2 Oct 2022 19:09:19 +0300 Subject: [PATCH 020/209] Further improvements --- src/btop_tools.cpp | 33 +++++++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index dd09696..ab93f00 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -44,6 +44,8 @@ using std::string_view; using std::to_string; using robin_hood::unordered_flat_map; +using namespace std::literals; // to use operator""s + namespace fs = std::filesystem; namespace rng = std::ranges; @@ -348,10 +350,33 @@ namespace Tools { string out; const size_t mult = (bit) ? 8 : 1; const bool mega = Config::getB("base_10_sizes"); - static const array mebiUnits_bit = {"bit", "Kib", "Mib", "Gib", "Tib", "Pib", "Eib", "Zib", "Yib", "Bib", "GEb"}; - static const array mebiUnits_byte = {"Byte", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB", "BiB", "GEB"}; - static const array megaUnits_bit = {"bit", "Kb", "Mb", "Gb", "Tb", "Pb", "Eb", "Zb", "Yb", "Bb", "Gb"}; - static const array megaUnits_byte = {"Byte", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", "BB", "GB"}; + + // taking advantage of type deduction for array creation (since C++17) + // combined with string literals (operator""s) + static const array mebiUnits_bit { + "bit"s, "Kib"s, "Mib"s, + "Gib"s, "Tib"s, "Pib"s, + "Eib"s, "Zib"s, "Yib"s, + "Bib"s, "GEb"s + }; + static const array mebiUnits_byte { + "Byte"s, "KiB"s, "MiB"s, + "GiB"s, "TiB"s, "PiB"s, + "EiB"s, "ZiB"s, "YiB"s, + "BiB"s, "GEB"s + }; + static const array megaUnits_bit { + "bit"s, "Kb"s, "Mb"s, + "Gb"s, "Tb"s, "Pb"s, + "Eb"s, "Zb"s, "Yb"s, + "Bb"s, "Gb"s + }; + static const array megaUnits_byte { + "Byte"s, "KB"s, "MB"s, + "GB"s, "TB"s, "PB"s, + "EB"s, "ZB"s, "YB"s, + "BB"s, "GB"s + }; const auto& units = (bit) ? ( mega ? megaUnits_bit : mebiUnits_bit) : ( mega ? megaUnits_byte : mebiUnits_byte); value *= 100 * mult; From eda68730718e5fcee5545ac30a114f3540eea53e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Sun, 2 Oct 2022 21:52:27 +0300 Subject: [PATCH 021/209] Further 'cleanup' --- src/btop_shared.cpp | 8 ++-- src/btop_shared.hpp | 95 +++++++++++++++++++++++++++++---------------- src/btop_theme.cpp | 62 +++++++++++++++++------------ src/btop_theme.hpp | 12 ++++-- 4 files changed, 112 insertions(+), 65 deletions(-) diff --git a/src/btop_shared.cpp b/src/btop_shared.cpp index 94806d5..0e597a1 100644 --- a/src/btop_shared.cpp +++ b/src/btop_shared.cpp @@ -21,7 +21,6 @@ tab-size = 4 #include #include -using std::string_literals::operator""s; namespace rng = std::ranges; using namespace Tools; @@ -99,7 +98,8 @@ namespace Proc { } } - void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, int cur_depth, const bool collapsed, const string& filter, bool found, const bool no_update, const bool should_filter) { + void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, + int cur_depth, const bool collapsed, const string& filter, bool found, const bool no_update, const bool should_filter) { auto cur_pos = out_procs.size(); bool filtering = false; @@ -132,7 +132,7 @@ namespace Proc { std::string_view cmd_view = cur_proc.cmd; cmd_view = cmd_view.substr((size_t)0, std::min(cmd_view.find(' '), cmd_view.size())); cmd_view = cmd_view.substr(std::min(cmd_view.find_last_of('/') + 1, cmd_view.size())); - cur_proc.short_cmd = (string)cmd_view; + cur_proc.short_cmd = string{cmd_view}; } } else { @@ -170,4 +170,4 @@ namespace Proc { } -} \ No newline at end of file +} diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 1eb81b6..2fed8a7 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -18,18 +18,26 @@ tab-size = 4 #pragma once -#include -#include -#include +#include #include #include -#include -#include -#include +#include +#include #include +#include +#include +#include #include -using std::string, std::vector, std::deque, robin_hood::unordered_flat_map, std::atomic, std::array, std::tuple; +using robin_hood::unordered_flat_map; +using std::array; +using std::atomic; +using std::deque; +using std::string; +using std::tuple; +using std::vector; + +using namespace std::literals; // for operator""s void term_resize(bool force=false); void banner_gen(); @@ -124,17 +132,21 @@ namespace Mem { extern string box; extern int x, y, width, height, min_width, min_height; extern bool has_swap, shown, redraw; - const array mem_names = {"used", "available", "cached", "free"}; - const array swap_names = {"swap_used", "swap_free"}; + const array mem_names { "used"s, "available"s, "cached"s, "free"s }; + const array swap_names { "swap_used"s, "swap_free"s }; extern int disk_ios; struct disk_info { std::filesystem::path dev; string name; - string fstype = ""; - std::filesystem::path stat = ""; - int64_t total = 0, used = 0, free = 0; - int used_percent = 0, free_percent = 0; + string fstype{}; // defaults to "" + std::filesystem::path stat{}; // defaults to "" + int64_t total{}; // defaults to 0 + int64_t used{}; // defaults to 0 + int64_t free{}; // defaults to 0 + int used_percent{}; // defaults to 0 + int free_percent{}; // defaults to 0 + array old_io = {0, 0, 0}; deque io_read = {}; deque io_write = {}; @@ -173,14 +185,20 @@ namespace Net { extern unordered_flat_map graph_max; struct net_stat { - uint64_t speed = 0, top = 0, total = 0, last = 0, offset = 0, rollover = 0; + uint64_t speed{}; // defaults to 0 + uint64_t top{}; // defaults to 0 + uint64_t total{}; // defaults to 0 + uint64_t last{}; // defaults to 0 + uint64_t offset{}; // defaults to 0 + uint64_t rollover{}; // defaults to 0 }; struct net_info { unordered_flat_map> bandwidth = { {"download", {}}, {"upload", {}} }; unordered_flat_map stat = { {"download", {}}, {"upload", {}} }; - string ipv4 = "", ipv6 = ""; - bool connected = false; + string ipv4{}; // defaults to "" + string ipv6{}; // defaults to "" + bool connected{}; // defaults to false }; extern unordered_flat_map current_net; @@ -232,25 +250,32 @@ namespace Proc { //* Container for process information struct proc_info { - size_t pid = 0; - string name = "", cmd = ""; - string short_cmd = ""; - size_t threads = 0; - int name_offset = 0; - string user = ""; - uint64_t mem = 0; - double cpu_p = 0.0, cpu_c = 0.0; + size_t pid{}; // defaults to 0 + string name{}; // defaults to "" + string cmd{}; // defaults to "" + string short_cmd{}; // defaults to "" + size_t threads{}; // defaults to 0 + int name_offset{}; // defaults to 0 + string user{}; // defaults to "" + uint64_t mem{}; // defaults to 0 + double cpu_p{}; // defaults to = 0.0 + double cpu_c{}; // defaults to = 0.0 char state = '0'; - uint64_t p_nice = 0, ppid = 0, cpu_s = 0, cpu_t = 0; - string prefix = ""; - size_t depth = 0, tree_index = 0; - bool collapsed = false, filtered = false; + uint64_t p_nice{}; // defaults to 0 + uint64_t ppid{}; // defaults to 0 + uint64_t cpu_s{}; // defaults to 0 + uint64_t cpu_t{}; // defaults to 0 + string prefix{}; // defaults to "" + size_t depth{}; // defaults to 0 + size_t tree_index{}; // defaults to 0 + bool collapsed{}; // defaults to false + bool filtered{}; // defaults to false }; //* Container for process info box struct detail_container { - size_t last_pid = 0; - bool skip_smaps = false; + size_t last_pid{}; // defaults to 0 + bool skip_smaps{}; // defaults to false proc_info entry; string elapsed, parent, status, io_read, io_write, memory; long long first_mem = -1; @@ -276,11 +301,15 @@ namespace Proc { }; //* Sort vector of proc_info's - void proc_sorter(vector& proc_vec, const string& sorting, const bool reverse, const bool tree = false); + void proc_sorter(vector& proc_vec, const string& sorting, + const bool reverse, const bool tree = false); //* Recursive sort of process tree - void tree_sort(vector& proc_vec, const string& sorting, const bool reverse, int& c_index, const int index_max, const bool collapsed = false); + void tree_sort(vector& proc_vec, const string& sorting, + const bool reverse, int& c_index, const int index_max, const bool collapsed = false); //* Generate process tree list - void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, int cur_depth, const bool collapsed, const string& filter, bool found=false, const bool no_update=false, const bool should_filter=false); + void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, + int cur_depth, const bool collapsed, const string& filter, + bool found=false, const bool no_update=false, const bool should_filter=false); } diff --git a/src/btop_theme.cpp b/src/btop_theme.cpp index 116e78b..4a73002 100644 --- a/src/btop_theme.cpp +++ b/src/btop_theme.cpp @@ -17,9 +17,7 @@ tab-size = 4 */ #include -#include #include -#include #include #include @@ -27,9 +25,19 @@ tab-size = 4 #include #include -using std::round, std::vector, std::stoi, std::views::iota, - std::clamp, std::max, std::min, std::ceil, std::to_string; +using std::ceil; +using std::clamp; +using std::max; +using std::min; +using std::quoted; +using std::round; +using std::stoi; +using std::to_string; +using std::vector; +using std::views::iota; + using namespace Tools; + namespace rng = std::ranges; namespace fs = std::filesystem; @@ -152,10 +160,12 @@ namespace Theme { string hex_to_color(string hexa, const bool& t_to_256, const string& depth) { if (hexa.size() > 1) { hexa.erase(0, 1); - for (auto& c : hexa) if (not isxdigit(c)) { - Logger::error("Invalid hex value: " + hexa); - return ""; - } + for (auto& c : hexa) { + if (not isxdigit(c)) { + Logger::error("Invalid hex value: " + hexa); + return ""; + } + } string pre = Fx::e + (depth == "fg" ? "38" : "48") + ";" + (t_to_256 ? "5;" : "2;"); if (hexa.size() == 2) { @@ -200,14 +210,17 @@ namespace Theme { array hex_to_dec(string hexa) { if (hexa.size() > 1) { hexa.erase(0, 1); - for (auto& c : hexa) if (not isxdigit(c)) return array{-1, -1, -1}; + for (auto& c : hexa) { + if (not isxdigit(c)) + return array{-1, -1, -1}; + } if (hexa.size() == 2) { int h_int = stoi(hexa, nullptr, 16); - return array{h_int, h_int, h_int}; + return array{h_int, h_int, h_int}; } else if (hexa.size() == 6) { - return array{ + return array{ stoi(hexa.substr(0, 2), nullptr, 16), stoi(hexa.substr(2, 2), nullptr, 16), stoi(hexa.substr(4, 2), nullptr, 16) @@ -247,11 +260,11 @@ namespace Theme { } else if (not source.at(name).empty()) { t_rgb = ssplit(source.at(name)); - if (t_rgb.size() != 3) - Logger::error("Invalid RGB decimal value: \"" + source.at(name) + "\""); - else { + if (t_rgb.size() != 3) { + Logger::error("Invalid RGB decimal value: \"" + source.at(name) + "\""); + } else { colors[name] = dec_to_color(stoi(t_rgb[0]), stoi(t_rgb[1]), stoi(t_rgb[2]), t_to_256, depth); - rgbs[name] = array{stoi(t_rgb[0]), stoi(t_rgb[1]), stoi(t_rgb[2])}; + rgbs[name] = array{stoi(t_rgb[0]), stoi(t_rgb[1]), stoi(t_rgb[2])}; } } @@ -287,12 +300,13 @@ namespace Theme { const bool& t_to_256 = Config::getB("lowcolor"); //? Insert values for processes greyscale gradient and processes color gradient - rgbs.insert({ { "proc_start", rgbs["main_fg"] }, - { "proc_mid", {-1, -1, -1} }, - { "proc_end", rgbs["inactive_fg"] }, - { "proc_color_start", rgbs["inactive_fg"] }, - { "proc_color_mid", {-1, -1, -1} }, - { "proc_color_end", rgbs["process_start"] }, + rgbs.insert({ + { "proc_start", rgbs["main_fg"] }, + { "proc_mid", {-1, -1, -1} }, + { "proc_end", rgbs["inactive_fg"] }, + { "proc_color_start", rgbs["inactive_fg"] }, + { "proc_color_mid", {-1, -1, -1} }, + { "proc_color_end", rgbs["process_start"] }, }); for (const auto& [name, source_arr] : rgbs) { @@ -315,10 +329,10 @@ namespace Theme { //? Split iteration in two passes of 50 + 51 instead of one pass of 101 if gradient has start, mid and end values defined int current_range = (input_colors[1][0] >= 0) ? 50 : 100; - for (const int& rgb : iota(0, 3)) { + for (int rgb : iota(0, 3)) { int start = 0, offset = 0; int end = (current_range == 50) ? 1 : 2; - for (const int& i : iota(0, 101)) { + for (int i : iota(0, 101)) { output_colors[i][rgb] = input_colors[start][rgb] + (i - offset) * (input_colors[end][rgb] - input_colors[start][rgb]) / current_range; //? Switch source arrays from start->mid to mid->end at 50 passes if mid is defined @@ -353,7 +367,7 @@ namespace Theme { const string base_name = rtrim(c.first, "_start"); string section = "_start"; int split = colors.at(base_name + "_mid").empty() ? 50 : 33; - for (const int& i : iota(0, 101)) { + for (int i : iota(0, 101)) { gradients[base_name][i] = colors.at(base_name + section); if (i == split) { section = (split == 33) ? "_mid" : "_end"; diff --git a/src/btop_theme.hpp b/src/btop_theme.hpp index fce093a..27c102b 100644 --- a/src/btop_theme.hpp +++ b/src/btop_theme.hpp @@ -18,12 +18,16 @@ tab-size = 4 #pragma once -#include -#include #include #include +#include +#include +#include -using std::string, robin_hood::unordered_flat_map, std::array; +using std::array; +using std::string; +using std::vector; +using robin_hood::unordered_flat_map; namespace Theme { extern std::filesystem::path theme_dir; @@ -63,4 +67,4 @@ namespace Theme { //* Return array of red, green and blue in decimal for color inline const std::array& dec(string name) { return rgbs.at(name); } -} \ No newline at end of file +} From 1fddbc1cd633e22a5eb8f7c7918c4042c942a135 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Mon, 3 Oct 2022 00:29:05 +0300 Subject: [PATCH 022/209] Further Cleanup Part 2 --- src/btop.cpp | 66 +++++++++++++++++--------- src/btop_config.cpp | 11 +++-- src/btop_config.hpp | 4 +- src/btop_draw.cpp | 90 ++++++++++++++++++++++++----------- src/btop_draw.hpp | 31 ++++++------ src/btop_input.cpp | 10 ++-- src/btop_input.hpp | 9 +++- src/btop_menu.cpp | 55 ++++++++++++++++------ src/btop_menu.hpp | 12 ++++- src/linux/btop_collect.cpp | 96 ++++++++++++++++++++++++-------------- 10 files changed, 261 insertions(+), 123 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index 5aff90c..858d668 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -46,12 +46,23 @@ tab-size = 4 #include #include -using std::string, std::string_view, std::vector, std::atomic, std::endl, std::cout, std::min, std::flush, std::endl; -using std::string_literals::operator""s, std::to_string; +using std::atomic; +using std::cout; +using std::endl; +using std::endl; +using std::flush; +using std::min; +using std::string; +using std::string_view; +using std::to_string; +using std::vector; + namespace fs = std::filesystem; namespace rng = std::ranges; + using namespace Tools; using namespace std::chrono_literals; +using namespace std::literals; namespace Global { const vector> Banner_src = { @@ -80,9 +91,9 @@ namespace Global { string exit_error_msg; atomic thread_exception (false); - bool debuginit = false; - bool debug = false; - bool utf_force = false; + bool debuginit{}; // defaults to false + bool debug{}; // defaults to false + bool utf_force{}; // defaults to false uint64_t start_time; @@ -92,8 +103,8 @@ namespace Global { atomic should_sleep (false); atomic _runner_started (false); - bool arg_tty = false; - bool arg_low_color = false; + bool arg_tty{}; // defaults to false + bool arg_low_color{}; // defaults to false int arg_preset = -1; } @@ -328,8 +339,14 @@ namespace Runner { pthread_mutex_t& pt_mutex; public: int status; - thread_lock(pthread_mutex_t& mtx) : pt_mutex(mtx) { pthread_mutex_init(&pt_mutex, NULL); status = pthread_mutex_lock(&pt_mutex); } - ~thread_lock() { if (status == 0) pthread_mutex_unlock(&pt_mutex); } + thread_lock(pthread_mutex_t& mtx) : pt_mutex(mtx) { + pthread_mutex_init(&pt_mutex, NULL); + status = pthread_mutex_lock(&pt_mutex); + } + ~thread_lock() { + if (status == 0) + pthread_mutex_unlock(&pt_mutex); + } }; //* Wrapper for raising priviliges when using SUID bit @@ -337,16 +354,18 @@ namespace Runner { int status = -1; public: gain_priv() { - if (Global::real_uid != Global::set_uid) this->status = seteuid(Global::set_uid); + if (Global::real_uid != Global::set_uid) + this->status = seteuid(Global::set_uid); } ~gain_priv() { - if (status == 0) status = seteuid(Global::real_uid); + if (status == 0) + status = seteuid(Global::real_uid); } }; string output; string empty_bg; - bool pause_output = false; + bool pause_output{}; // defaults to false sigset_t mask; pthread_t runner_id; pthread_mutex_t mtx; @@ -394,8 +413,7 @@ namespace Runner { } //? ------------------------------- Secondary thread: async launcher and drawing ---------------------------------- - void * _runner(void * _) { - (void)_; + void * _runner(void *) { //? Block some signals in this thread to avoid deadlock from any signal handlers trying to stop this thread sigemptyset(&mask); // sigaddset(&mask, SIGINT); @@ -438,7 +456,9 @@ namespace Runner { //! DEBUG stats if (Global::debug) { - if (debug_bg.empty() or redraw) Runner::debug_bg = Draw::createBox(2, 2, 32, 8, "", true, "debug"); + if (debug_bg.empty() or redraw) + Runner::debug_bg = Draw::createBox(2, 2, 32, 8, "", true, "debug"); + debug_times.clear(); debug_times["total"] = {0, 0}; } @@ -463,7 +483,7 @@ namespace Runner { if (Global::debug) debug_timer("cpu", draw_done); } catch (const std::exception& e) { - throw std::runtime_error("Cpu:: -> " + (string)e.what()); + throw std::runtime_error("Cpu:: -> " + string{e.what()}); } } @@ -483,7 +503,7 @@ namespace Runner { if (Global::debug) debug_timer("mem", draw_done); } catch (const std::exception& e) { - throw std::runtime_error("Mem:: -> " + (string)e.what()); + throw std::runtime_error("Mem:: -> " + string{e.what()}); } } @@ -503,7 +523,7 @@ namespace Runner { if (Global::debug) debug_timer("net", draw_done); } catch (const std::exception& e) { - throw std::runtime_error("Net:: -> " + (string)e.what()); + throw std::runtime_error("Net:: -> " + string{e.what()}); } } @@ -523,12 +543,12 @@ namespace Runner { if (Global::debug) debug_timer("proc", draw_done); } catch (const std::exception& e) { - throw std::runtime_error("Proc:: -> " + (string)e.what()); + throw std::runtime_error("Proc:: -> " + string{e.what()}); } } } catch (const std::exception& e) { - Global::exit_error_msg = "Exception in runner thread -> " + (string)e.what(); + Global::exit_error_msg = "Exception in runner thread -> " + string{e.what()}; Global::thread_exception = true; Input::interrupt = true; stopping = true; @@ -752,7 +772,7 @@ int main(int argc, char **argv) { } else { string found; - bool set_failure = false; + bool set_failure{}; // defaults to false for (const auto loc_env : array{"LANG", "LC_ALL"}) { if (std::getenv(loc_env) != NULL and str_to_upper(s_replace((string)std::getenv(loc_env), "-", "")).ends_with("UTF8")) { found = std::getenv(loc_env); @@ -848,7 +868,7 @@ int main(int argc, char **argv) { Shared::init(); } catch (const std::exception& e) { - Global::exit_error_msg = "Exception in Shared::init() -> " + (string)e.what(); + Global::exit_error_msg = "Exception in Shared::init() -> " + string{e.what()}; clean_quit(1); } @@ -960,7 +980,7 @@ int main(int argc, char **argv) { } } catch (const std::exception& e) { - Global::exit_error_msg = "Exception in main loop -> " + (string)e.what(); + Global::exit_error_msg = "Exception in main loop -> " + string{e.what()}; clean_quit(1); } diff --git a/src/btop_config.cpp b/src/btop_config.cpp index 479101a..8a38394 100644 --- a/src/btop_config.cpp +++ b/src/btop_config.cpp @@ -26,9 +26,14 @@ tab-size = 4 #include #include -using std::array, std::atomic, std::string_view, std::string_literals::operator""s; +using std::array; +using std::atomic; +using std::string_view; + namespace fs = std::filesystem; namespace rng = std::ranges; + +using namespace std::literals; using namespace Tools; //* Functions and variables for reading and writing the btop config file @@ -378,7 +383,7 @@ namespace Config { return false; } catch (const std::exception& e) { - validError = (string)e.what(); + validError = string{e.what()}; return false; } @@ -498,7 +503,7 @@ namespace Config { boolsTmp.clear(); } catch (const std::exception& e) { - Global::exit_error_msg = "Exception during Config::unlock() : " + (string)e.what(); + Global::exit_error_msg = "Exception during Config::unlock() : " + string{e.what()}; clean_quit(1); } diff --git a/src/btop_config.hpp b/src/btop_config.hpp index 9d2f63c..fc1bd91 100644 --- a/src/btop_config.hpp +++ b/src/btop_config.hpp @@ -23,7 +23,9 @@ tab-size = 4 #include #include -using std::string, std::vector, robin_hood::unordered_flat_map; +using std::string; +using std::vector; +using robin_hood::unordered_flat_map; //* Functions and variables for reading and writing the btop config file namespace Config { diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 780c6c1..3c3a41e 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -29,11 +29,21 @@ tab-size = 4 #include #include - -using std::round, std::views::iota, std::string_literals::operator""s, std::clamp, std::array, std::floor, std::max, std::min, - std::to_string, std::cmp_equal, std::cmp_less, std::cmp_greater, std::cmp_less_equal; +using std::array; +using std::clamp; +using std::cmp_equal; +using std::cmp_greater; +using std::cmp_less; +using std::cmp_less_equal; +using std::floor; +using std::max; +using std::min; +using std::round; +using std::to_string; +using std::views::iota; using namespace Tools; +using namespace std::literals; // for operator""s namespace rng = std::ranges; namespace Symbols { @@ -207,7 +217,7 @@ namespace Draw { return first + Fx::bl + "█" + Fx::ubl + uresize(text.substr(pos), limit - ulen(first)); } catch (const std::exception& e) { - Logger::error("In TextEdit::operator() : " + (string)e.what()); + Logger::error("In TextEdit::operator() : " + string{e.what()}); } } return text.substr(0, pos) + Fx::bl + "█" + Fx::ubl + text.substr(pos); @@ -217,7 +227,9 @@ namespace Draw { this->text.clear(); } - string createBox(const int x, const int y, const int width, const int height, string line_color, const bool fill, const string title, const string title2, const int num) { + string createBox(const int x, const int y, const int width, + const int height, string line_color, const bool fill, + const string title, const string title2, const int num) { string out; if (line_color.empty()) line_color = Theme::c("div_line"); const auto& tty_mode = Config::getB("tty_mode"); @@ -273,8 +285,9 @@ namespace Draw { {"/host", Tools::hostname()}, {"/uptime", ""} }; - static time_t c_time = 0; - static size_t clock_len = 0; + + static time_t c_time{}; // defaults to 0 + static size_t clock_len{}; // defaults to 0 static string clock_str; if (auto n_time = time(NULL); not force and n_time == c_time) @@ -327,7 +340,8 @@ namespace Draw { //* Meter class ------------------------------------------------------------------------------------------------------------> Meter::Meter() {} - Meter::Meter(const int width, const string& color_gradient, const bool invert) : width(width), color_gradient(color_gradient), invert(invert) {} + Meter::Meter(const int width, const string& color_gradient, const bool invert) + : width(width), color_gradient(color_gradient), invert(invert) {} string Meter::operator()(int value) { if (width < 1) return ""; @@ -419,8 +433,11 @@ namespace Draw { Graph::Graph() {} - Graph::Graph(int width, int height, const string& color_gradient, const deque& data, const string& symbol, bool invert, bool no_zero, long long max_value, long long offset) - : width(width), height(height), color_gradient(color_gradient), invert(invert), no_zero(no_zero), offset(offset) { + Graph::Graph(int width, int height, const string& color_gradient, + const deque& data, const string& symbol, + bool invert, bool no_zero, long long max_value, long long offset) + : width(width), height(height), color_gradient(color_gradient), + invert(invert), no_zero(no_zero), offset(offset) { if (Config::getB("tty_mode") or symbol == "tty") this->symbol = "tty"; else if (symbol != "default") this->symbol = symbol; else this->symbol = Config::getS("graph_symbol"); @@ -500,7 +517,9 @@ namespace Cpu { const string& title_left = Theme::c("cpu_box") + (cpu_bottom ? Symbols::title_left_down : Symbols::title_left); const string& title_right = Theme::c("cpu_box") + (cpu_bottom ? Symbols::title_right_down : Symbols::title_right); static int bat_pos = 0, bat_len = 0; - if (cpu.cpu_percent.at("total").empty() or cpu.core_percent.at(0).empty() or (show_temps and cpu.temp.at(0).empty())) return ""; + if (cpu.cpu_percent.at("total").empty() + or cpu.core_percent.at(0).empty() + or (show_temps and cpu.temp.at(0).empty())) return ""; string out; out.reserve(width * height); @@ -527,20 +546,30 @@ namespace Cpu { //? Graphs & meters graph_upper = Draw::Graph{x + width - b_width - 3, graph_up_height, "cpu", cpu.cpu_percent.at(graph_up_field), graph_symbol, false, true}; cpu_meter = Draw::Meter{b_width - (show_temps ? 23 - (b_column_size <= 1 and b_columns == 1 ? 6 : 0) : 11), "cpu"}; - if (not single_graph) - graph_lower = Draw::Graph{x + width - b_width - 3, graph_low_height, "cpu", cpu.cpu_percent.at(graph_lo_field), graph_symbol, Config::getB("cpu_invert_lower"), true}; + if (not single_graph) { + graph_lower = Draw::Graph{ + x + width - b_width - 3, + graph_low_height, "cpu", + cpu.cpu_percent.at(graph_lo_field), + graph_symbol, + Config::getB("cpu_invert_lower"), true + }; + } + if (mid_line) { out += Mv::to(y + graph_up_height + 1, x) + Fx::ub + Theme::c("cpu_box") + Symbols::div_left + Theme::c("div_line") + Symbols::h_line * (width - b_width - 2) + Symbols::div_right + Mv::to(y + graph_up_height + 1, x + ((width - b_width) / 2) - ((graph_up_field.size() + graph_lo_field.size()) / 2) - 4) + Theme::c("main_fg") + graph_up_field + Mv::r(1) + "▲▼" + Mv::r(1) + graph_lo_field; } + if (b_column_size > 0 or extra_width > 0) { core_graphs.clear(); for (const auto& core_data : cpu.core_percent) { core_graphs.emplace_back(5 * b_column_size + extra_width, 1, "cpu", core_data, graph_symbol); } } + if (show_temps) { temp_graphs.clear(); temp_graphs.emplace_back(5, 1, "temp", cpu.temp.at(0), graph_symbol, false, false, cpu.temp_max, -23); @@ -554,8 +583,8 @@ namespace Cpu { //? Draw battery if enabled and present if (Config::getB("show_battery") and has_battery) { - static int old_percent = 0; - static long old_seconds = 0; + static int old_percent{}; // defaults to = 0 + static long old_seconds{}; // defaults to = 0 static string old_status; static Draw::Meter bat_meter {10, "cpu", true}; static const unordered_flat_map bat_symbols = { @@ -626,7 +655,7 @@ namespace Cpu { } out += Theme::c("div_line") + Symbols::v_line; - } catch (const std::exception& e) { throw std::runtime_error("graphs, clock, meter : " + (string)e.what()); } + } catch (const std::exception& e) { throw std::runtime_error("graphs, clock, meter : " + string{e.what()}); } //? Core text and graphs int cx = 0, cy = 1, cc = 0, core_width = (b_column_size == 0 ? 2 : 3); @@ -672,8 +701,6 @@ namespace Cpu { out += Mv::to(b_y + b_height - 2, b_x + cx + 1) + Theme::c("main_fg") + lavg_pre + lavg; } - - redraw = false; return out + Fx::reset; } @@ -771,11 +798,20 @@ namespace Mem { if (io_graph_combined) { deque combined(disk.io_read.size(), 0); rng::transform(disk.io_read, disk.io_write, combined.begin(), std::plus()); - io_graphs[name] = Draw::Graph{disks_width - (io_mode ? 0 : 6), disks_io_h, "available", combined, graph_symbol, false, true, speed}; + io_graphs[name] = Draw::Graph{ + disks_width - (io_mode ? 0 : 6), + disks_io_h, "available", combined, + graph_symbol, false, true, speed}; } else { - io_graphs[name + "_read"] = Draw::Graph{disks_width, half_height, "free", disk.io_read, graph_symbol, false, true, speed}; - io_graphs[name + "_write"] = Draw::Graph{disks_width, disks_io_h - half_height, "used", disk.io_write, graph_symbol, true, true, speed}; + io_graphs[name + "_read"] = Draw::Graph{ + disks_width, half_height, "free", + disk.io_read, graph_symbol, false, + true, speed}; + io_graphs[name + "_write"] = Draw::Graph{ + disks_width, disks_io_h - half_height, + "used", disk.io_write, graph_symbol, + true, true, speed}; } } } @@ -924,8 +960,6 @@ namespace Mem { if (cy < height - 2) out += Mv::to(y+1+cy, x+1+cx) + divider; } - - redraw = false; return out + Fx::reset; } @@ -969,8 +1003,13 @@ namespace Net { graphs.clear(); if (net.bandwidth.at("download").empty() or net.bandwidth.at("upload").empty()) return out + Fx::reset; - graphs["download"] = Draw::Graph{width - b_width - 2, u_graph_height, "download", net.bandwidth.at("download"), graph_symbol, false, true, down_max}; - graphs["upload"] = Draw::Graph{width - b_width - 2, d_graph_height, "upload", net.bandwidth.at("upload"), graph_symbol, true, true, up_max}; + graphs["download"] = Draw::Graph{ + width - b_width - 2, u_graph_height, "download", + net.bandwidth.at("download"), graph_symbol, + false, true, down_max}; + graphs["upload"] = Draw::Graph{ + width - b_width - 2, d_graph_height, "upload", + net.bandwidth.at("upload"), graph_symbol, true, true, up_max}; //? Interface selector and buttons @@ -1020,7 +1059,6 @@ namespace Net { } } - redraw = false; return out + Fx::reset; } diff --git a/src/btop_draw.hpp b/src/btop_draw.hpp index e425845..6da4af5 100644 --- a/src/btop_draw.hpp +++ b/src/btop_draw.hpp @@ -24,7 +24,11 @@ tab-size = 4 #include #include -using std::string, std::array, std::vector, robin_hood::unordered_flat_map, std::deque; +using robin_hood::unordered_flat_map; +using std::array; +using std::deque; +using std::string; +using std::vector; namespace Symbols { const string h_line = "─"; @@ -62,8 +66,8 @@ namespace Draw { //* An editable text field class TextEdit { - size_t pos = 0; - size_t upos = 0; + size_t pos{}; // defaults to 0 + size_t upos{}; // defaults to 0 bool numeric; public: string text; @@ -75,7 +79,9 @@ namespace Draw { }; //* Create a box and return as a string - string createBox(const int x, const int y, const int width, const int height, string line_color="", const bool fill=false, const string title="", const string title2="", const int num=0); + string createBox(const int x, const int y, const int width, + const int height, string line_color="", const bool fill=false, + const string title="", const string title2="", const int num=0); bool update_clock(bool force=false); @@ -109,15 +115,12 @@ namespace Draw { public: Graph(); - Graph( int width, - int height, - const string& color_gradient, - const deque& data, - const string& symbol="default", - bool invert=false, - bool no_zero=false, - long long max_value=0, - long long offset=0); + Graph(int width, int height, + const string& color_gradient, + const deque& data, + const string& symbol="default", + bool invert=false, bool no_zero=false, + long long max_value=0, long long offset=0); //* Add last value from back of and return string representation of graph string& operator()(const deque& data, const bool data_same=false); @@ -134,4 +137,4 @@ namespace Proc { extern Draw::TextEdit filter; extern unordered_flat_map p_graphs; extern unordered_flat_map p_counters; -} \ No newline at end of file +} diff --git a/src/btop_input.cpp b/src/btop_input.cpp index 586dea9..43d7a6d 100644 --- a/src/btop_input.cpp +++ b/src/btop_input.cpp @@ -30,8 +30,11 @@ tab-size = 4 #include #include -using std::cin, std::vector, std::string_literals::operator""s; +using std::cin; +using std::vector; + using namespace Tools; +using namespace std::literals; // for operator""s namespace rng = std::ranges; namespace Input { @@ -545,10 +548,9 @@ namespace Input { } } - catch (const std::exception& e) { - throw std::runtime_error("Input::process(\"" + key + "\") : " + (string)e.what()); + throw std::runtime_error("Input::process(\"" + key + "\") : " + string{e.what()}); } } -} \ No newline at end of file +} diff --git a/src/btop_input.hpp b/src/btop_input.hpp index 7342709..2e8c0a4 100644 --- a/src/btop_input.hpp +++ b/src/btop_input.hpp @@ -24,7 +24,12 @@ tab-size = 4 #include #include -using robin_hood::unordered_flat_map, std::array, std::string, std::atomic, std::deque; +using robin_hood::unordered_flat_map; +using std::array; +using std::atomic; +using std::deque; +using std::string; + /* The input functions relies on the following std::cin options being set: cin.sync_with_stdio(false); cin.tie(NULL); @@ -65,4 +70,4 @@ namespace Input { //* Process actions for input void process(const string& key); -} \ No newline at end of file +} diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index 8037e0f..71696f1 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -32,8 +32,18 @@ tab-size = 4 #include #include -using std::deque, robin_hood::unordered_flat_map, std::array, std::views::iota, std::ref, std::max, std::min, std::ceil, std::clamp; +using robin_hood::unordered_flat_map; +using std::array; +using std::ceil; +using std::clamp; +using std::deque; +using std::max; +using std::min; +using std::ref; +using std::views::iota; + using namespace Tools; + namespace fs = std::filesystem; namespace rng = std::ranges; @@ -41,11 +51,11 @@ namespace Menu { atomic active (false); string bg; - bool redraw = true; + bool redraw{true}; int currentMenu = -1; msgBox messageBox; - int signalToSend = 0; - int signalKillRet = 0; + int signalToSend{}; // defaults to 0 + int signalKillRet{}; // defaults to 0 const array P_Signals = { "0", @@ -713,7 +723,10 @@ namespace Menu { int signalChoose(const string& key) { auto& s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); - static int x = 0, y = 0, selected_signal = -1; + static int x{}; // defaults to 0 + static int y{}; // defaults to 0 + static int selected_signal = -1; + if (bg.empty()) selected_signal = -1; auto& out = Global::overlay; int retval = Changed; @@ -912,7 +925,8 @@ namespace Menu { int mainMenu(const string& key) { enum MenuItems { Options, Help, Quit }; - static int y = 0, selected = 0; + static int y{}; // defaults to 0 + static int selected{}; // defaults to 0 static vector colors_selected; static vector colors_normal; auto& tty_mode = Config::getB("tty_mode"); @@ -969,7 +983,6 @@ namespace Menu { retval = NoChange; } - if (retval == Changed) { auto& out = Global::overlay; out = bg + Fx::reset + Fx::b; @@ -986,14 +999,23 @@ namespace Menu { out += Fx::reset; } - return (redraw ? Changed : retval); } int optionsMenu(const string& key) { enum Predispositions { isBool, isInt, isString, is2D, isBrowseable, isEditable}; - static int y = 0, x = 0, height = 0, page = 0, pages = 0, selected = 0, select_max = 0, item_height = 0, selected_cat = 0, max_items = 0, last_sel = 0; - static bool editing = false; + static int y{}; // defaults to 0 + static int x{}; // defaults to 0 + static int height{}; // defaults to 0 + static int page{}; // defaults to 0 + static int pages{}; // defaults to 0 + static int selected{}; // defaults to 0 + static int select_max{}; // defaults to 0 + static int item_height{}; // defaults to 0 + static int selected_cat{}; // defaults to 0 + static int max_items{}; // defaults to 0 + static int last_sel{}; // defaults to 0 + static bool editing{}; // defaults to false static Draw::TextEdit editor; static string warnings; static bitset<8> selPred; @@ -1025,9 +1047,9 @@ namespace Menu { Theme::updateThemes(); } int retval = Changed; - bool recollect = false; - bool screen_redraw = false; - bool theme_refresh = false; + bool recollect{}; // defaults to false + bool screen_redraw{}; // defaults to false + bool theme_refresh{}; // defaults to false //? Draw background if needed else process input if (redraw) { @@ -1320,7 +1342,12 @@ namespace Menu { } int helpMenu(const string& key) { - static int y = 0, x = 0, height = 0, page = 0, pages = 0; + static int y{}; // defaults to 0 + static int x{}; // defaults to 0 + static int height{}; // defaults to 0 + static int page{}; // defaults to 0 + static int pages{}; // defaults to 0 + if (bg.empty()) page = 0; int retval = Changed; diff --git a/src/btop_menu.hpp b/src/btop_menu.hpp index b4fcab1..0017962 100644 --- a/src/btop_menu.hpp +++ b/src/btop_menu.hpp @@ -25,7 +25,10 @@ tab-size = 4 #include -using std::string, std::atomic, std::vector, std::bitset; +using std::atomic; +using std::bitset; +using std::string; +using std::vector; namespace Menu { @@ -43,7 +46,12 @@ namespace Menu { //? Strings in content vector is not checked for box width overflow class msgBox { string box_contents, button_left, button_right; - int height = 0, width = 0, boxtype = 0, selected = 0, x = 0, y = 0; + int height{}; // defaults to 0 + int width{}; // defaults to 0 + int boxtype{}; // defaults to 0 + int selected{}; // defaults to 0 + int x{}; // defaults to 0 + int y{}; // defaults to 0 public: enum BoxTypes { OK, YES_NO, NO_YES }; enum msgReturn { diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index e986d35..fca5e99 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -35,12 +35,22 @@ tab-size = 4 #include #include -using std::ifstream, std::numeric_limits, std::streamsize, std::round, std::max, std::min; -using std::clamp, std::string_literals::operator""s, std::cmp_equal, std::cmp_less, std::cmp_greater; +using std::clamp; +using std::cmp_equal; +using std::cmp_greater; +using std::cmp_less; +using std::ifstream; +using std::max; +using std::min; +using std::numeric_limits; +using std::round; +using std::streamsize; + namespace fs = std::filesystem; namespace rng = std::ranges; -using namespace Tools; +using namespace Tools; +using namespace std::literals; // for operator""s //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace Cpu { @@ -50,7 +60,8 @@ namespace Cpu { vector available_sensors = {"Auto"}; cpu_info current_cpu; fs::path freq_path = "/sys/devices/system/cpu/cpufreq/policy0/scaling_cur_freq"; - bool got_sensors = false, cpu_temp_only = false; + bool got_sensors{}; // defaults to false + bool cpu_temp_only{}; // defaults to false //* Populate found_sensors map bool get_sensors(); @@ -64,9 +75,9 @@ namespace Cpu { struct Sensor { fs::path path; string label; - int64_t temp = 0; - int64_t high = 0; - int64_t crit = 0; + int64_t temp{}; // defaults to 0 + int64_t high{}; // defaults to 0 + int64_t crit{}; // defaults to 0 }; unordered_flat_map found_sensors; @@ -144,7 +155,10 @@ namespace Cpu { bool has_battery = true; tuple current_bat; - const array time_names = {"user", "nice", "system", "idle", "iowait", "irq", "softirq", "steal", "guest", "guest_nice"}; + const array time_names { + "user"s, "nice"s, "system"s, "idle"s, "iowait"s, + "irq"s, "softirq"s, "steal"s, "guest"s, "guest_nice"s + }; unordered_flat_map cpu_old = { {"totals", 0}, @@ -387,11 +401,14 @@ namespace Cpu { } string get_cpuHz() { - static int failed = 0; - if (failed > 4) return ""s; + static int failed{}; // defaults to 0 + + if (failed > 4) + return ""s; + string cpuhz; try { - double hz = 0.0; + double hz{}; // defaults to 0.0 //? Try to get freq from /sys/devices/system/cpu/cpufreq/policy first (faster) if (not freq_path.empty()) { hz = stod(readfile(freq_path, "0.0")) / 1000; @@ -416,7 +433,8 @@ namespace Cpu { } } - if (hz <= 1 or hz >= 1000000) throw std::runtime_error("Failed to read /sys/devices/system/cpu/cpufreq/policy and /proc/cpuinfo."); + if (hz <= 1 or hz >= 1000000) + throw std::runtime_error("Failed to read /sys/devices/system/cpu/cpufreq/policy and /proc/cpuinfo."); if (hz >= 1000) { if (hz >= 10000) cpuhz = to_string((int)round(hz / 1000)); // Future proof until we reach THz speeds :) @@ -428,9 +446,10 @@ namespace Cpu { } catch (const std::exception& e) { - if (++failed < 5) return ""s; + if (++failed < 5) + return ""s; else { - Logger::warning("get_cpuHZ() : " + (string)e.what()); + Logger::warning("get_cpuHZ() : " + string{e.what()}); return ""s; } } @@ -445,7 +464,9 @@ namespace Cpu { //? Try to get core mapping from /proc/cpuinfo ifstream cpuinfo(Shared::procPath / "cpuinfo"); if (cpuinfo.good()) { - int cpu, core, n = 0; + int cpu{}; // defaults to 0 + int core{}; // defaults to 0 + int n{}; // defaults to 0 for (string instr; cpuinfo >> instr;) { if (instr == "processor") { cpuinfo.ignore(SSmax, ':'); @@ -714,9 +735,9 @@ namespace Cpu { } } catch (const std::exception& e) { - Logger::debug("get_cpuHz() : " + (string)e.what()); + Logger::debug("get_cpuHz() : " + string{e.what()}); if (cread.bad()) throw std::runtime_error("Failed to read /proc/stat"); - else throw std::runtime_error("collect() : " + (string)e.what()); + else throw std::runtime_error("collect() : " + string{e.what()}); } if (Config::getB("show_cpu_freq")) @@ -733,10 +754,10 @@ namespace Cpu { } namespace Mem { - bool has_swap = false; + bool has_swap{}; // defaults to false vector fstab; fs::file_time_type fstab_time; - int disk_ios = 0; + int disk_ios{}; // defaults to 0 vector last_found; const std::regex zfs_size_regex("^size\\s+\\d\\s+(\\d+)"); @@ -1114,14 +1135,14 @@ namespace Mem { while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } } else { - Logger::debug("Error in Mem::collect() : when opening " + (string)disk.stat); + Logger::debug("Error in Mem::collect() : when opening " + string{disk.stat}); } diskread.close(); } old_uptime = uptime; } catch (const std::exception& e) { - Logger::warning("Error in Mem::collect() : " + (string)e.what()); + Logger::warning("Error in Mem::collect() : " + string{e.what()}); } } @@ -1182,7 +1203,13 @@ namespace Mem { bool zfs_collect_pool_total_stats(struct disk_info &disk) { ifstream diskread; - int64_t bytes_read, bytes_write, io_ticks, bytes_read_total = 0, bytes_write_total = 0, io_ticks_total = 0, objects_read = 0; + int64_t bytes_read; + int64_t bytes_write; + int64_t io_ticks; + int64_t bytes_read_total{}; // defaults to 0 + int64_t bytes_write_total{}; // defaults to 0 + int64_t io_ticks_total{}; // defaults to 0 + int64_t objects_read{}; // defaults to 0 // looking through all files that start with 'objset' for (const auto& file: fs::directory_iterator(disk.stat)) { @@ -1258,11 +1285,11 @@ namespace Net { net_info empty_net = {}; vector interfaces; string selected_iface; - int errors = 0; + int errors{}; // defaults to 0 unordered_flat_map graph_max = { {"download", {}}, {"upload", {}} }; unordered_flat_map> max_count = { {"download", {}}, {"upload", {}} }; - bool rescale = true; - uint64_t timestamp = 0; + bool rescale{true}; + uint64_t timestamp{}; // defaults to 0 //* RAII wrapper for getifaddrs class getifaddr_wrapper { @@ -1296,7 +1323,7 @@ namespace Net { string ipv4, ipv6; //? Iteration over all items in getifaddrs() list - for (auto* ifa = if_wrap(); ifa != NULL; ifa = ifa->ifa_next) { + for (auto* ifa = if_wrap(); ifa != NULL; ifa = ifa->ifa_next) { if (ifa->ifa_addr == NULL) continue; family = ifa->ifa_addr->sa_family; const auto& iface = ifa->ifa_name; @@ -1329,7 +1356,7 @@ namespace Net { auto& saved_stat = net.at(iface).stat.at(dir); auto& bandwidth = net.at(iface).bandwidth.at(dir); - uint64_t val = 0; + uint64_t val{}; // defaults to 0 try { val = (uint64_t)stoull(readfile(sys_file, "0")); } catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} @@ -1450,15 +1477,15 @@ namespace Proc { unordered_flat_map uid_user; string current_sort; string current_filter; - bool current_rev = false; + bool current_rev{}; // defaults to false fs::file_time_type passwd_time; uint64_t cputimes; int collapse = -1, expand = -1; - uint64_t old_cputimes = 0; - atomic numpids = 0; - int filter_found = 0; + uint64_t old_cputimes{}; // defaults to 0 + atomic numpids{}; // defaults to 0 + int filter_found{}; // defaults to 0 detail_container detailed; constexpr size_t KTHREADD = 2; @@ -1589,7 +1616,7 @@ namespace Proc { const int cmult = (per_core) ? Shared::coreCount : 1; bool got_detailed = false; - static size_t proc_clear_count = 0; + static size_t proc_clear_count{}; // defaults to 0 //* Use pids from last update if only changing filter, sorting or tree options if (no_update and not current_procs.empty()) { @@ -1647,6 +1674,7 @@ namespace Proc { for (const auto& d: fs::directory_iterator(Shared::procPath)) { if (Runner::stopping) return current_procs; + if (pread.is_open()) pread.close(); const string pid_str = d.path().filename(); @@ -1662,7 +1690,7 @@ namespace Proc { //? Check if pid already exists in current_procs auto find_old = rng::find(current_procs, pid, &proc_info::pid); - bool no_cache = false; + bool no_cache{}; // defaults to false if (find_old == current_procs.end()) { current_procs.push_back({pid}); find_old = current_procs.end() - 1; @@ -1945,6 +1973,6 @@ namespace Tools { catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} } - throw std::runtime_error("Failed get uptime from from " + (string)Shared::procPath + "/uptime"); + throw std::runtime_error("Failed get uptime from from " + string{Shared::procPath} + "/uptime"); } } From 96b770cfdb0f6c4e83958ce68d1351d95927d9dc Mon Sep 17 00:00:00 2001 From: aristocratos Date: Mon, 3 Oct 2022 08:49:41 +0200 Subject: [PATCH 023/209] Changed: Using sysconf(_SC_NPROCESSORS_CONF) for number of cores instead of sysconf(_SC_NPROCESSORS_ONLN) --- src/linux/btop_collect.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index ecbc7bd..255d1df 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -95,7 +95,7 @@ namespace Shared { if (passwd_path.empty()) Logger::warning("Could not read /etc/passwd, will show UID instead of username."); - coreCount = sysconf(_SC_NPROCESSORS_ONLN); + coreCount = sysconf(_SC_NPROCESSORS_CONF); if (coreCount < 1) { coreCount = 1; Logger::warning("Could not determine number of cores, defaulting to 1."); From 2f1bf0df013ecc831598eed7aa46bf962065b1eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 11:47:26 +0300 Subject: [PATCH 024/209] No need for const & in bool --- src/btop_theme.cpp | 8 ++++---- src/btop_theme.hpp | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/btop_theme.cpp b/src/btop_theme.cpp index 4a73002..52fe6e1 100644 --- a/src/btop_theme.cpp +++ b/src/btop_theme.cpp @@ -157,7 +157,7 @@ namespace Theme { } } - string hex_to_color(string hexa, const bool& t_to_256, const string& depth) { + string hex_to_color(string hexa, bool t_to_256, const string& depth) { if (hexa.size() > 1) { hexa.erase(0, 1); for (auto& c : hexa) { @@ -196,7 +196,7 @@ namespace Theme { return ""; } - string dec_to_color(int r, int g, int b, const bool& t_to_256, const string& depth) { + string dec_to_color(int r, int g, int b, bool t_to_256, const string& depth) { string pre = Fx::e + (depth == "fg" ? "38" : "48") + ";" + (t_to_256 ? "5;" : "2;"); r = std::clamp(r, 0, 255); g = std::clamp(g, 0, 255); @@ -234,7 +234,7 @@ namespace Theme { void generateColors(const unordered_flat_map& source) { vector t_rgb; string depth; - const bool& t_to_256 = Config::getB("lowcolor"); + bool t_to_256 = Config::getB("lowcolor"); colors.clear(); rgbs.clear(); for (const auto& [name, color] : Default_theme) { if (name == "main_bg" and not Config::getB("theme_background")) { @@ -297,7 +297,7 @@ namespace Theme { //* Generate color gradients from two or three colors, 101 values indexed 0-100 void generateGradients() { gradients.clear(); - const bool& t_to_256 = Config::getB("lowcolor"); + bool t_to_256 = Config::getB("lowcolor"); //? Insert values for processes greyscale gradient and processes color gradient rgbs.insert({ diff --git a/src/btop_theme.hpp b/src/btop_theme.hpp index 27c102b..65687ff 100644 --- a/src/btop_theme.hpp +++ b/src/btop_theme.hpp @@ -40,13 +40,13 @@ namespace Theme { //* Args hexa: ["#000000"-"#ffffff"] for color, ["#00"-"#ff"] for greyscale //* t_to_256: [true|false] convert 24bit value to 256 color value //* depth: ["fg"|"bg"] for either a foreground color or a background color - string hex_to_color(string hexa, const bool& t_to_256=false, const string& depth="fg"); + string hex_to_color(string hexa, bool t_to_256=false, const string& depth="fg"); //* Generate escape sequence for 24-bit or 256 color and return as a string //* Args r: [0-255], g: [0-255], b: [0-255] //* t_to_256: [true|false] convert 24bit value to 256 color value //* depth: ["fg"|"bg"] for either a foreground color or a background color - string dec_to_color(int r, int g, int b, const bool& t_to_256=false, const string& depth="fg"); + string dec_to_color(int r, int g, int b, bool t_to_256=false, const string& depth="fg"); //* Update list of paths for available themes void updateThemes(); From 98b35d20a5b3a8e31552de41caecacdd05a3d614 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 11:57:15 +0300 Subject: [PATCH 025/209] More 'No need for const & in bool' --- src/btop_config.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/btop_config.hpp b/src/btop_config.hpp index fc1bd91..f60e48d 100644 --- a/src/btop_config.hpp +++ b/src/btop_config.hpp @@ -65,7 +65,7 @@ namespace Config { bool _locked(const string& name); //* Return bool for config key - inline const bool& getB(const string& name) { return bools.at(name); } + inline bool getB(const string& name) { return bools.at(name); } //* Return integer for config key inline const int& getI(const string& name) { return ints.at(name); } @@ -81,7 +81,7 @@ namespace Config { bool stringValid(const string& name, const string& value); //* Set config key to bool - inline void set(const string& name, const bool& value) { + inline void set(const string& name, bool value) { if (_locked(name)) boolsTmp.insert_or_assign(name, value); else bools.at(name) = value; } From 36a180033db62743d70f1332fde3ea1102181555 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 12:11:12 +0300 Subject: [PATCH 026/209] Forgot to update 'auto' usage wherever necessary --- src/btop_draw.cpp | 66 +++++++++++++++++++------------------- src/btop_input.cpp | 4 +-- src/btop_menu.cpp | 6 ++-- src/linux/btop_collect.cpp | 18 +++++------ 4 files changed, 47 insertions(+), 47 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 3c3a41e..3ae4210 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -106,8 +106,8 @@ namespace Draw { if (redraw) banner.clear(); if (banner.empty()) { string b_color, bg, fg, oc, letter; - auto& lowcolor = Config::getB("lowcolor"); - auto& tty_mode = Config::getB("tty_mode"); + auto lowcolor = Config::getB("lowcolor"); + auto tty_mode = Config::getB("tty_mode"); for (size_t z = 0; const auto& line : Global::Banner_src) { if (const auto w = ulen(line[1]); w > width) width = w; if (tty_mode) { @@ -232,8 +232,8 @@ namespace Draw { const string title, const string title2, const int num) { string out; if (line_color.empty()) line_color = Theme::c("div_line"); - const auto& tty_mode = Config::getB("tty_mode"); - const auto& rounded = Config::getB("rounded_corners"); + const auto tty_mode = Config::getB("tty_mode"); + const auto rounded = Config::getB("rounded_corners"); const string numbering = (num == 0) ? "" : Theme::c("hi_fg") + (tty_mode ? std::to_string(num) : Symbols::superscript.at(clamp(num, 0, 9))); const auto& right_up = (tty_mode or not rounded ? Symbols::right_up : Symbols::round_right_up); const auto& left_up = (tty_mode or not rounded ? Symbols::left_up : Symbols::round_left_up); @@ -504,16 +504,16 @@ namespace Cpu { if (Runner::stopping) return ""; if (force_redraw) redraw = true; const bool show_temps = (Config::getB("check_temp") and got_sensors); - auto& single_graph = Config::getB("cpu_single_graph"); + auto single_graph = Config::getB("cpu_single_graph"); const bool hide_cores = show_temps and (cpu_temp_only or not Config::getB("show_coretemp")); const int extra_width = (hide_cores ? max(6, 6 * b_column_size) : 0); auto& graph_up_field = Config::getS("cpu_graph_upper"); auto& graph_lo_field = Config::getS("cpu_graph_lower"); - auto& tty_mode = Config::getB("tty_mode"); + auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_cpu")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); auto& temp_scale = Config::getS("temp_scale"); - auto& cpu_bottom = Config::getB("cpu_bottom"); + auto cpu_bottom = Config::getB("cpu_bottom"); const string& title_left = Theme::c("cpu_box") + (cpu_bottom ? Symbols::title_left_down : Symbols::title_left); const string& title_right = Theme::c("cpu_box") + (cpu_bottom ? Symbols::title_right_down : Symbols::title_right); static int bat_pos = 0, bat_len = 0; @@ -725,14 +725,14 @@ namespace Mem { string draw(const mem_info& mem, const bool force_redraw, const bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; - auto& show_swap = Config::getB("show_swap"); - auto& swap_disk = Config::getB("swap_disk"); - auto& show_disks = Config::getB("show_disks"); - auto& show_io_stat = Config::getB("show_io_stat"); - auto& io_mode = Config::getB("io_mode"); - auto& io_graph_combined = Config::getB("io_graph_combined"); - auto& use_graphs = Config::getB("mem_graphs"); - auto& tty_mode = Config::getB("tty_mode"); + auto show_swap = Config::getB("show_swap"); + auto swap_disk = Config::getB("swap_disk"); + auto show_disks = Config::getB("show_disks"); + auto show_io_stat = Config::getB("show_io_stat"); + auto io_mode = Config::getB("io_mode"); + auto io_graph_combined = Config::getB("io_graph_combined"); + auto use_graphs = Config::getB("mem_graphs"); + auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_mem")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); auto totalMem = Mem::get_totalMem(); @@ -979,9 +979,9 @@ namespace Net { string draw(const net_info& net, const bool force_redraw, const bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; - auto& net_sync = Config::getB("net_sync"); - auto& net_auto = Config::getB("net_auto"); - auto& tty_mode = Config::getB("tty_mode"); + auto net_sync = Config::getB("net_sync"); + auto net_auto = Config::getB("net_auto"); + auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_net")); string ip_addr = (net.ipv4.empty() ? net.ipv6 : net.ipv4); if (old_ip != ip_addr) { @@ -1090,7 +1090,7 @@ namespace Proc { auto selected = Config::getI("proc_selected"); auto last_selected = Config::getI("proc_last_selected"); const int select_max = (Config::getB("show_detailed") ? Proc::select_max - 8 : Proc::select_max); - auto& vim_keys = Config::getB("vim_keys"); + auto vim_keys = Config::getB("vim_keys"); int numpids = Proc::numpids; if ((cmd_key == "up" or (vim_keys and cmd_key == "k")) and selected > 0) { @@ -1147,16 +1147,16 @@ namespace Proc { string draw(const vector& plist, const bool force_redraw, const bool data_same) { if (Runner::stopping) return ""; - auto& proc_tree = Config::getB("proc_tree"); + auto proc_tree = Config::getB("proc_tree"); const bool show_detailed = (Config::getB("show_detailed") and cmp_equal(Proc::detailed.last_pid, Config::getI("detailed_pid"))); const bool proc_gradient = (Config::getB("proc_gradient") and not Config::getB("lowcolor") and Theme::gradients.contains("proc")); - auto& proc_colors = Config::getB("proc_colors"); - auto& tty_mode = Config::getB("tty_mode"); + auto proc_colors = Config::getB("proc_colors"); + auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_proc")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); - auto& mem_bytes = Config::getB("proc_mem_bytes"); - auto& vim_keys = Config::getB("vim_keys"); - auto& show_graphs = Config::getB("proc_cpu_graphs"); + auto mem_bytes = Config::getB("proc_mem_bytes"); + auto vim_keys = Config::getB("vim_keys"); + auto show_graphs = Config::getB("proc_cpu_graphs"); start = Config::getI("proc_start"); selected = Config::getI("proc_selected"); const int y = show_detailed ? Proc::y + 8 : Proc::y; @@ -1263,7 +1263,7 @@ namespace Proc { } //? Filter - auto& filtering = Config::getB("proc_filtering"); // ? filter(20) : Config::getS("proc_filter")) + auto filtering = Config::getB("proc_filtering"); // ? filter(20) : Config::getS("proc_filter")) const auto filter_text = (filtering) ? filter(max(6, width - 58)) : uresize(Config::getS("proc_filter"), max(6, width - 58)); out += Mv::to(y, x+9) + title_left + (not filter_text.empty() ? Fx::b : "") + Theme::c("hi_fg") + 'f' + Theme::c("title") + (not filter_text.empty() ? ' ' + filter_text : "ilter") @@ -1557,10 +1557,10 @@ namespace Draw { void calcSizes() { atomic_wait(Runner::active); Config::unlock(); - auto& boxes = Config::getS("shown_boxes"); - auto& cpu_bottom = Config::getB("cpu_bottom"); - auto& mem_below_net = Config::getB("mem_below_net"); - auto& proc_left = Config::getB("proc_left"); + auto boxes = Config::getS("shown_boxes"); + auto cpu_bottom = Config::getB("cpu_bottom"); + auto mem_below_net = Config::getB("mem_below_net"); + auto proc_left = Config::getB("proc_left"); Cpu::box.clear(); Mem::box.clear(); @@ -1629,9 +1629,9 @@ namespace Draw { //* Calculate and draw mem box outlines if (Mem::shown) { using namespace Mem; - auto& show_disks = Config::getB("show_disks"); - auto& swap_disk = Config::getB("swap_disk"); - auto& mem_graphs = Config::getB("mem_graphs"); + auto show_disks = Config::getB("show_disks"); + auto swap_disk = Config::getB("swap_disk"); + auto mem_graphs = Config::getB("mem_graphs"); width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); height = ceil((double)Term::height * (100 - Cpu::height_p * Cpu::shown - Net::height_p * Net::shown) / 100) + 1; diff --git a/src/btop_input.cpp b/src/btop_input.cpp index 43d7a6d..3a09152 100644 --- a/src/btop_input.cpp +++ b/src/btop_input.cpp @@ -238,8 +238,8 @@ namespace Input { void process(const string& key) { if (key.empty()) return; try { - auto& filtering = Config::getB("proc_filtering"); - auto& vim_keys = Config::getB("vim_keys"); + auto filtering = Config::getB("proc_filtering"); + auto vim_keys = Config::getB("vim_keys"); auto help_key = (vim_keys ? "H" : "h"); auto kill_key = (vim_keys ? "K" : "k"); //? Global input actions diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index 71696f1..3ca22da 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -929,7 +929,7 @@ namespace Menu { static int selected{}; // defaults to 0 static vector colors_selected; static vector colors_normal; - auto& tty_mode = Config::getB("tty_mode"); + auto tty_mode = Config::getB("tty_mode"); if (bg.empty()) selected = 0; int retval = Changed; @@ -1034,8 +1034,8 @@ namespace Menu { {"cpu_sensor", std::cref(Cpu::available_sensors)}, {"selected_battery", std::cref(Config::available_batteries)}, }; - auto& tty_mode = Config::getB("tty_mode"); - auto& vim_keys = Config::getB("vim_keys"); + auto tty_mode = Config::getB("tty_mode"); + auto vim_keys = Config::getB("vim_keys"); if (max_items == 0) { for (const auto& cat : categories) { if ((int)cat.size() > max_items) max_items = cat.size(); diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index c8b2fe1..3bed684 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -808,10 +808,10 @@ namespace Mem { auto collect(const bool no_update) -> mem_info& { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; - auto& show_swap = Config::getB("show_swap"); - auto& swap_disk = Config::getB("swap_disk"); - auto& show_disks = Config::getB("show_disks"); - auto& zfs_arc_cached = Config::getB("zfs_arc_cached"); + auto show_swap = Config::getB("show_swap"); + auto swap_disk = Config::getB("swap_disk"); + auto show_disks = Config::getB("show_disks"); + auto zfs_arc_cached = Config::getB("zfs_arc_cached"); auto totalMem = get_totalMem(); auto& mem = current_mem; @@ -899,9 +899,9 @@ namespace Mem { try { auto& disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; - auto& use_fstab = Config::getB("use_fstab"); - auto& only_physical = Config::getB("only_physical"); - auto& zfs_hide_datasets = Config::getB("zfs_hide_datasets"); + auto use_fstab = Config::getB("use_fstab"); + auto only_physical = Config::getB("only_physical"); + auto zfs_hide_datasets = Config::getB("zfs_hide_datasets"); auto& disks = mem.disks; ifstream diskread; @@ -1327,8 +1327,8 @@ namespace Net { auto collect(const bool no_update) -> net_info& { auto& net = current_net; auto& config_iface = Config::getS("net_iface"); - auto& net_sync = Config::getB("net_sync"); - auto& net_auto = Config::getB("net_auto"); + auto net_sync = Config::getB("net_sync"); + auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { From ab7fe62e65f363e6161534d58e8de7f98350f964 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 12:56:14 +0300 Subject: [PATCH 027/209] Fix variable initialization to 'auto' for getB() It does not make sense to return a `const bool&` as we are dealing with Boolean literals that are `prvalue`s of type bool. The compiler is smart enough to do the necessary optimizations wherever is applicable. --- src/btop_config.hpp | 7 ------- src/btop_draw.cpp | 12 ++++++------ src/btop_menu.cpp | 8 ++++---- src/btop_tools.cpp | 2 +- src/freebsd/btop_collect.cpp | 20 ++++++++++---------- src/linux/btop_collect.cpp | 10 +++++----- src/osx/btop_collect.cpp | 20 ++++++++++---------- 7 files changed, 36 insertions(+), 43 deletions(-) diff --git a/src/btop_config.hpp b/src/btop_config.hpp index f60e48d..bbebc9b 100644 --- a/src/btop_config.hpp +++ b/src/btop_config.hpp @@ -113,10 +113,3 @@ namespace Config { //* Write the config file to disk void write(); } - - - - - - - diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 3ae4210..abb68fe 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -232,8 +232,8 @@ namespace Draw { const string title, const string title2, const int num) { string out; if (line_color.empty()) line_color = Theme::c("div_line"); - const auto tty_mode = Config::getB("tty_mode"); - const auto rounded = Config::getB("rounded_corners"); + auto tty_mode = Config::getB("tty_mode"); + auto rounded = Config::getB("rounded_corners"); const string numbering = (num == 0) ? "" : Theme::c("hi_fg") + (tty_mode ? std::to_string(num) : Symbols::superscript.at(clamp(num, 0, 9))); const auto& right_up = (tty_mode or not rounded ? Symbols::right_up : Symbols::round_right_up); const auto& left_up = (tty_mode or not rounded ? Symbols::left_up : Symbols::round_left_up); @@ -300,7 +300,7 @@ namespace Draw { } auto& out = Global::clock; - const auto& cpu_bottom = Config::getB("cpu_bottom"); + auto cpu_bottom = Config::getB("cpu_bottom"); const auto& x = Cpu::x; const auto y = (cpu_bottom ? Cpu::y + Cpu::height - 1 : Cpu::y); const auto& width = Cpu::width; @@ -503,9 +503,9 @@ namespace Cpu { string draw(const cpu_info& cpu, const bool force_redraw, const bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; - const bool show_temps = (Config::getB("check_temp") and got_sensors); + bool show_temps = (Config::getB("check_temp") and got_sensors); auto single_graph = Config::getB("cpu_single_graph"); - const bool hide_cores = show_temps and (cpu_temp_only or not Config::getB("show_coretemp")); + bool hide_cores = show_temps and (cpu_temp_only or not Config::getB("show_coretemp")); const int extra_width = (hide_cores ? max(6, 6 * b_column_size) : 0); auto& graph_up_field = Config::getS("cpu_graph_upper"); auto& graph_lo_field = Config::getS("cpu_graph_lower"); @@ -1590,7 +1590,7 @@ namespace Draw { //* Calculate and draw cpu box outlines if (Cpu::shown) { using namespace Cpu; - const bool show_temp = (Config::getB("check_temp") and got_sensors); + bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p) / 100)); x = 1; diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index 3ca22da..c5822f2 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -632,8 +632,8 @@ namespace Menu { msgBox::msgBox() {} msgBox::msgBox(int width, int boxtype, vector content, string title) : width(width), boxtype(boxtype) { - const auto& tty_mode = Config::getB("tty_mode"); - const auto& rounded = Config::getB("rounded_corners"); + auto tty_mode = Config::getB("tty_mode"); + auto rounded = Config::getB("rounded_corners"); const auto& right_up = (tty_mode or not rounded ? Symbols::right_up : Symbols::round_right_up); const auto& left_up = (tty_mode or not rounded ? Symbols::left_up : Symbols::round_left_up); const auto& right_down = (tty_mode or not rounded ? Symbols::right_down : Symbols::round_right_down); @@ -722,7 +722,7 @@ namespace Menu { }; int signalChoose(const string& key) { - auto& s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); + auto s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); static int x{}; // defaults to 0 static int y{}; // defaults to 0 static int selected_signal = -1; @@ -852,7 +852,7 @@ namespace Menu { } int signalSend(const string& key) { - auto& s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); + auto s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); if (s_pid == 0) return Closed; if (redraw) { atomic_wait(Runner::active); diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index ab93f00..7e64f74 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -349,7 +349,7 @@ namespace Tools { string floating_humanizer(uint64_t value, const bool shorten, size_t start, const bool bit, const bool per_second) { string out; const size_t mult = (bit) ? 8 : 1; - const bool mega = Config::getB("base_10_sizes"); + bool mega = Config::getB("base_10_sizes"); // taking advantage of type deduction for array creation (since C++17) // combined with string literals (operator""s) diff --git a/src/freebsd/btop_collect.cpp b/src/freebsd/btop_collect.cpp index 9e5be73..bc01333 100644 --- a/src/freebsd/btop_collect.cpp +++ b/src/freebsd/btop_collect.cpp @@ -614,9 +614,9 @@ namespace Mem { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; - auto &show_swap = Config::getB("show_swap"); - auto &show_disks = Config::getB("show_disks"); - auto &swap_disk = Config::getB("swap_disk"); + auto show_swap = Config::getB("show_swap"); + auto show_disks = Config::getB("show_disks"); + auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; static const bool snapped = (getenv("BTOP_SNAPPED") != NULL); @@ -670,7 +670,7 @@ namespace Mem { double uptime = system_uptime(); auto &disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; - // auto &only_physical = Config::getB("only_physical"); + // auto only_physical = Config::getB("only_physical"); auto &disks = mem.disks; vector filter; if (not disks_filter.empty()) { @@ -806,8 +806,8 @@ namespace Net { auto collect(const bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); - auto &net_sync = Config::getB("net_sync"); - auto &net_auto = Config::getB("net_auto"); + auto net_sync = Config::getB("net_sync"); + auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { @@ -1080,11 +1080,11 @@ namespace Proc { //* Collects and sorts process information from /proc auto collect(const bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); - const auto &reverse = Config::getB("proc_reversed"); + auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); - const auto &per_core = Config::getB("proc_per_core"); - const auto &tree = Config::getB("proc_tree"); - const auto &show_detailed = Config::getB("show_detailed"); + auto per_core = Config::getB("proc_per_core"); + auto tree = Config::getB("proc_tree"); + auto show_detailed = Config::getB("show_detailed"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 3bed684..b8b53f1 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -1614,12 +1614,12 @@ namespace Proc { //* Collects and sorts process information from /proc auto collect(const bool no_update) -> vector& { const auto& sorting = Config::getS("proc_sorting"); - const auto& reverse = Config::getB("proc_reversed"); + auto reverse = Config::getB("proc_reversed"); const auto& filter = Config::getS("proc_filter"); - const auto& per_core = Config::getB("proc_per_core"); - const auto& should_filter_kernel = Config::getB("proc_filter_kernel"); - const auto& tree = Config::getB("proc_tree"); - const auto& show_detailed = Config::getB("show_detailed"); + auto per_core = Config::getB("proc_per_core"); + auto should_filter_kernel = Config::getB("proc_filter_kernel"); + auto tree = Config::getB("proc_tree"); + auto show_detailed = Config::getB("show_detailed"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; diff --git a/src/osx/btop_collect.cpp b/src/osx/btop_collect.cpp index d7877a1..1ae33c4 100644 --- a/src/osx/btop_collect.cpp +++ b/src/osx/btop_collect.cpp @@ -666,9 +666,9 @@ namespace Mem { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; - auto &show_swap = Config::getB("show_swap"); - auto &show_disks = Config::getB("show_disks"); - auto &swap_disk = Config::getB("swap_disk"); + auto show_swap = Config::getB("show_swap"); + auto show_disks = Config::getB("show_disks"); + auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; static const bool snapped = (getenv("BTOP_SNAPPED") != NULL); @@ -712,7 +712,7 @@ namespace Mem { double uptime = system_uptime(); auto &disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; - // auto &only_physical = Config::getB("only_physical"); + // auto only_physical = Config::getB("only_physical"); auto &disks = mem.disks; vector filter; if (not disks_filter.empty()) { @@ -845,8 +845,8 @@ namespace Net { auto collect(const bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); - auto &net_sync = Config::getB("net_sync"); - auto &net_auto = Config::getB("net_auto"); + auto net_sync = Config::getB("net_sync"); + auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { @@ -1108,11 +1108,11 @@ namespace Proc { //* Collects and sorts process information from /proc auto collect(const bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); - const auto &reverse = Config::getB("proc_reversed"); + auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); - const auto &per_core = Config::getB("proc_per_core"); - const auto &tree = Config::getB("proc_tree"); - const auto &show_detailed = Config::getB("show_detailed"); + auto per_core = Config::getB("proc_per_core"); + auto tree = Config::getB("proc_tree"); + auto show_detailed = Config::getB("show_detailed"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; From 820391494be8f6bdd1a044f37c08cdd120643eb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 16:20:20 +0300 Subject: [PATCH 028/209] Avoid the unnecessary use of copy constructor When you want to pass a `std::string` to `std::string_view`, prefer to do such operation during object initialization via `{}` so you can avoid to use the copy constructor, which can be expensive under certain situations. --- src/btop_tools.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 7e64f74..9dd7333 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -262,7 +262,7 @@ namespace Tools { } string ltrim(const string& str, const string& t_str) { - string_view str_v = str; + string_view str_v{str}; while (str_v.starts_with(t_str)) str_v.remove_prefix(t_str.size()); @@ -270,7 +270,7 @@ namespace Tools { } string rtrim(const string& str, const string& t_str) { - string_view str_v = str; + string_view str_v{str}; while (str_v.ends_with(t_str)) str_v.remove_suffix(t_str.size()); From afeef173fc459c361dc963bc244d5c77d775af62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 17:06:39 +0300 Subject: [PATCH 029/209] Remove const from bool variables --- src/btop_tools.cpp | 83 +++++++++++++++++++++++++++++++++------------- src/btop_tools.hpp | 20 +++++------ 2 files changed, 70 insertions(+), 33 deletions(-) diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 9dd7333..2d4c70e 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -288,41 +288,56 @@ namespace Tools { return out; } - string ljust(string str, const size_t x, const bool utf, const bool wide, const bool limit) { + string ljust(string str, const size_t x, bool utf, bool wide, bool limit) { if (utf) { - if (limit and ulen(str, wide) > x) return uresize(str, x, wide); + if (limit and ulen(str, wide) > x) + return uresize(str, x, wide); + return str + string(max((int)(x - ulen(str)), 0), ' '); } else { - if (limit and str.size() > x) { str.resize(x); return str; } + if (limit and str.size() > x) { + str.resize(x); + return str; + } return str + string(max((int)(x - str.size()), 0), ' '); } } - string rjust(string str, const size_t x, const bool utf, const bool wide, const bool limit) { + string rjust(string str, const size_t x, bool utf, bool wide, bool limit) { if (utf) { - if (limit and ulen(str, wide) > x) return uresize(str, x, wide); + if (limit and ulen(str, wide) > x) + return uresize(str, x, wide); + return string(max((int)(x - ulen(str)), 0), ' ') + str; } else { - if (limit and str.size() > x) { str.resize(x); return str; }; + if (limit and str.size() > x) { + str.resize(x); + return str; + }; return string(max((int)(x - str.size()), 0), ' ') + str; } } - string cjust(string str, const size_t x, const bool utf, const bool wide, const bool limit) { + string cjust(string str, const size_t x, bool utf, bool wide, bool limit) { if (utf) { - if (limit and ulen(str, wide) > x) return uresize(str, x, wide); + if (limit and ulen(str, wide) > x) + return uresize(str, x, wide); + return string(max((int)ceil((double)(x - ulen(str)) / 2), 0), ' ') + str + string(max((int)floor((double)(x - ulen(str)) / 2), 0), ' '); } else { - if (limit and str.size() > x) { str.resize(x); return str; } + if (limit and str.size() > x) { + str.resize(x); + return str; + } return string(max((int)ceil((double)(x - str.size()) / 2), 0), ' ') + str + string(max((int)floor((double)(x - str.size()) / 2), 0), ' '); } } string trans(const string& str) { - string_view oldstr = str; + string_view oldstr{str}; string newstr; newstr.reserve(str.size()); for (size_t pos; (pos = oldstr.find(' ')) != string::npos;) { @@ -346,7 +361,7 @@ namespace Tools { return out; } - string floating_humanizer(uint64_t value, const bool shorten, size_t start, const bool bit, const bool per_second) { + string floating_humanizer(uint64_t value, bool shorten, size_t start, bool bit, bool per_second) { string out; const size_t mult = (bit) ? 8 : 1; bool mega = Config::getB("base_10_sizes"); @@ -403,15 +418,29 @@ namespace Tools { } if (out.empty()) { out = to_string(value); - if (not mega and out.size() == 4 and start > 0) { out.pop_back(); out.insert(2, ".");} - else if (out.size() == 3 and start > 0) out.insert(1, "."); - else if (out.size() >= 2) out.resize(out.size() - 2); + if (not mega and out.size() == 4 and start > 0) { + out.pop_back(); + out.insert(2, "."); + } + else if (out.size() == 3 and start > 0) { + out.insert(1, "."); + } + else if (out.size() >= 2) { + out.resize(out.size() - 2); + } } if (shorten) { auto f_pos = out.find('.'); - if (f_pos == 1 and out.size() > 3) out = to_string(round(stof(out) * 10) / 10).substr(0,3); - else if (f_pos != string::npos) out = to_string((int)round(stof(out))); - if (out.size() > 3) { out = to_string((int)(out[0] - '0') + 1); start++;} + if (f_pos == 1 and out.size() > 3) { + out = to_string(round(stof(out) * 10) / 10).substr(0,3); + } + else if (f_pos != string::npos) { + out = to_string((int)round(stof(out))); + } + if (out.size() > 3) { + out = to_string((int)(out[0] - '0') + 1); + start++; + } out.push_back(units[start][0]); } else out += " " + units[start]; @@ -421,11 +450,19 @@ namespace Tools { } std::string operator*(const string& str, int64_t n) { - if (n < 1 or str.empty()) return ""; - else if(n == 1) return str; + if (n < 1 or str.empty()) { + return ""; + } + else if (n == 1) { + return str; + } + string new_str; new_str.reserve(str.size() * n); - for (; n > 0; n--) new_str.append(str); + + for (; n > 0; n--) + new_str.append(str); + return new_str; } @@ -437,11 +474,11 @@ namespace Tools { return ss.str(); } - void atomic_wait(const atomic& atom, const bool old) noexcept { + void atomic_wait(const atomic& atom, bool old) noexcept { while (atom.load(std::memory_order_relaxed) == old ) busy_wait(); } - void atomic_wait_for(const atomic& atom, const bool old, const uint64_t wait_ms) noexcept { + void atomic_wait_for(const atomic& atom, bool old, const uint64_t wait_ms) noexcept { const uint64_t start_time = time_ms(); while (atom.load(std::memory_order_relaxed) == old and (time_ms() - start_time < wait_ms)) sleep_ms(1); } @@ -463,7 +500,7 @@ namespace Tools { for (string readstr; getline(file, readstr); out += readstr); } catch (const std::exception& e) { - Logger::error("readfile() : Exception when reading " + (string)path + " : " + e.what()); + Logger::error("readfile() : Exception when reading " + string{path} + " : " + e.what()); return fallback; } return (out.empty() ? fallback : out); diff --git a/src/btop_tools.hpp b/src/btop_tools.hpp index c4d4279..52c8e65 100644 --- a/src/btop_tools.hpp +++ b/src/btop_tools.hpp @@ -150,7 +150,7 @@ namespace Tools { size_t wide_ulen(const std::wstring& w_str); //* Return number of UTF8 characters in a string (wide=true for column size needed on terminal) - inline size_t ulen(const string& str, const bool wide=false) { + inline size_t ulen(const string& str, bool wide = false) { return (wide ? wide_ulen(str) : std::ranges::count_if(str, [](char c) { return (static_cast(c) & 0xC0) != 0x80; })); } @@ -270,25 +270,25 @@ namespace Tools { } //* Left justify string if is greater than length, limit return size to by default - string ljust(string str, const size_t x, const bool utf=false, const bool wide=false, const bool limit=true); + string ljust(string str, const size_t x, bool utf = false, bool wide = false, bool limit = true); //* Right justify string if is greater than length, limit return size to by default - string rjust(string str, const size_t x, const bool utf=false, const bool wide=false, const bool limit=true); + string rjust(string str, const size_t x, bool utf = false, bool wide = false, bool limit = true); //* Center justify string if is greater than length, limit return size to by default - string cjust(string str, const size_t x, const bool utf=false, const bool wide=false, const bool limit=true); + string cjust(string str, const size_t x, bool utf = false, bool wide = false, bool limit = true); //* Replace whitespaces " " with escape code for move right string trans(const string& str); //* Convert seconds to format "d ::" and return string - string sec_to_dhms(size_t seconds, bool no_days=false, bool no_seconds=false); + string sec_to_dhms(size_t seconds, bool no_days = false, bool no_seconds = false); //* Scales up in steps of 1024 to highest positive value unit and returns string with unit suffixed //* bit=True or defaults to bytes //* start=int to set 1024 multiplier starting unit //* short=True always returns 0 decimals and shortens unit to 1 character - string floating_humanizer(uint64_t value, const bool shorten=false, size_t start=0, const bool bit=false, const bool per_second=false); + string floating_humanizer(uint64_t value, bool shorten = false, size_t start=0, bool bit = false, bool per_second = false); //* Add std::string operator * : Repeat string number of times std::string operator*(const string& str, int64_t n); @@ -311,21 +311,21 @@ namespace Tools { #endif } - void atomic_wait(const atomic& atom, const bool old=true) noexcept; + void atomic_wait(const atomic& atom, bool old = true) noexcept; - void atomic_wait_for(const atomic& atom, const bool old=true, const uint64_t wait_ms=0) noexcept; + void atomic_wait_for(const atomic& atom, bool old = true, const uint64_t wait_ms = 0) noexcept; //* Sets atomic to true on construct, sets to false on destruct class atomic_lock { atomic& atom; bool not_true{}; // defaults to false public: - atomic_lock(atomic& atom, bool wait=false); + atomic_lock(atomic& atom, bool wait = false); ~atomic_lock(); }; //* Read a complete file and return as a string - string readfile(const std::filesystem::path& path, const string& fallback=""); + string readfile(const std::filesystem::path& path, const string& fallback = ""); //* Convert a celsius value to celsius, fahrenheit, kelvin or rankin and return tuple with new value and unit. auto celsius_to(const long long& celsius, const string& scale) -> tuple; From 8331cb36f8ae9d65ffdccdba7fe916b62d740f60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 17:33:53 +0300 Subject: [PATCH 030/209] More const bool cleanup --- src/btop_draw.cpp | 11 +++++++---- src/btop_draw.hpp | 6 +++--- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index abb68fe..ec0750f 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -228,10 +228,13 @@ namespace Draw { } string createBox(const int x, const int y, const int width, - const int height, string line_color, const bool fill, + const int height, string line_color, bool fill, const string title, const string title2, const int num) { string out; - if (line_color.empty()) line_color = Theme::c("div_line"); + + if (line_color.empty()) + line_color = Theme::c("div_line"); + auto tty_mode = Config::getB("tty_mode"); auto rounded = Config::getB("rounded_corners"); const string numbering = (num == 0) ? "" : Theme::c("hi_fg") + (tty_mode ? std::to_string(num) : Symbols::superscript.at(clamp(num, 0, 9))); @@ -243,12 +246,12 @@ namespace Draw { out = Fx::reset + line_color; //? Draw horizontal lines - for (const int& hpos : {y, y + height - 1}) { + for (const int& hpos : {y, y + height - 1}) { out += Mv::to(hpos, x) + Symbols::h_line * (width - 1); } //? Draw vertical lines and fill if enabled - for (const int& hpos : iota(y + 1, y + height - 1)) { + for (const int& hpos : iota(y + 1, y + height - 1)) { out += Mv::to(hpos, x) + Symbols::v_line + ((fill) ? string(width - 2, ' ') : Mv::r(width - 2)) + Symbols::v_line; diff --git a/src/btop_draw.hpp b/src/btop_draw.hpp index 6da4af5..59a0e69 100644 --- a/src/btop_draw.hpp +++ b/src/btop_draw.hpp @@ -80,10 +80,10 @@ namespace Draw { //* Create a box and return as a string string createBox(const int x, const int y, const int width, - const int height, string line_color="", const bool fill=false, - const string title="", const string title2="", const int num=0); + const int height, string line_color = "", bool fill = false, + const string title = "", const string title2 = "", const int num = 0); - bool update_clock(bool force=false); + bool update_clock(bool force = false); //* Class holding a percentage meter class Meter { From f0e413ed6fd91f794394e60073819cb81b0492f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=A3=CF=84=CE=AD=CF=86=CE=B1=CE=BD=CE=BF=CF=82?= Date: Tue, 4 Oct 2022 21:36:04 +0300 Subject: [PATCH 031/209] All but two places `const bool` have been updated I haven't touched `include/robin_hood.h` as I don't know whether it's a third-party header file that could get rewritten at a later time of a possible future release by the author(s) of it. --- src/btop.cpp | 2 +- src/btop_draw.cpp | 26 ++++++++++++------------ src/btop_draw.hpp | 4 ++-- src/btop_shared.cpp | 6 +++--- src/btop_shared.hpp | 27 ++++++++++++------------- src/btop_tools.cpp | 38 ++++++++++++++++++++++++------------ src/btop_tools.hpp | 6 +++--- src/freebsd/btop_collect.cpp | 12 ++++++------ src/linux/btop_collect.cpp | 10 +++++----- src/osx/btop_collect.cpp | 12 ++++++------ 10 files changed, 77 insertions(+), 66 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index 858d668..d75ef22 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -604,7 +604,7 @@ namespace Runner { //? ------------------------------------------ Secondary thread end ----------------------------------------------- //* Runs collect and draw in a secondary thread, unlocks and locks config to update cached values - void run(const string& box, const bool no_update, const bool force_redraw) { + void run(const string& box, bool no_update, bool force_redraw) { atomic_wait_for(active, true, 5000); if (active) { Logger::error("Stall in Runner thread, restarting!"); diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index ec0750f..bc550fd 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -343,7 +343,7 @@ namespace Draw { //* Meter class ------------------------------------------------------------------------------------------------------------> Meter::Meter() {} - Meter::Meter(const int width, const string& color_gradient, const bool invert) + Meter::Meter(const int width, const string& color_gradient, bool invert) : width(width), color_gradient(color_gradient), invert(invert) {} string Meter::operator()(int value) { @@ -366,7 +366,7 @@ namespace Draw { //* Graph class ------------------------------------------------------------------------------------------------------------> void Graph::_create(const deque& data, int data_offset) { - const bool mult = (data.size() - data_offset > 1); + bool mult = (data.size() - data_offset > 1); const auto& graph_symbol = Symbols::graph_symbols.at(symbol + '_' + (invert ? "down" : "up")); array result; const float mod = (height == 1) ? 0.3 : 0.1; @@ -464,7 +464,7 @@ namespace Draw { this->_create(data, data_offset); } - string& Graph::operator()(const deque& data, const bool data_same) { + string& Graph::operator()(const deque& data, bool data_same) { if (data_same) return out; //? Make room for new characters on graph @@ -503,7 +503,7 @@ namespace Cpu { vector core_graphs; vector temp_graphs; - string draw(const cpu_info& cpu, const bool force_redraw, const bool data_same) { + string draw(const cpu_info& cpu, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; bool show_temps = (Config::getB("check_temp") and got_sensors); @@ -725,7 +725,7 @@ namespace Mem { unordered_flat_map disk_meters_free; unordered_flat_map io_graphs; - string draw(const mem_info& mem, const bool force_redraw, const bool data_same) { + string draw(const mem_info& mem, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; auto show_swap = Config::getB("show_swap"); @@ -884,7 +884,7 @@ namespace Mem { if (show_disks) { const auto& disks = mem.disks; cx = mem_width; cy = 0; - const bool big_disk = disks_width >= 25; + bool big_disk = disks_width >= 25; divider = Mv::l(1) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line * disks_width + Theme::c("mem_box") + Fx::ub + Symbols::div_right + Mv::l(disks_width); const string hu_div = Theme::c("div_line") + Symbols::h_line + Theme::c("main_fg"); if (io_mode) { @@ -979,7 +979,7 @@ namespace Net { unordered_flat_map graphs; string box; - string draw(const net_info& net, const bool force_redraw, const bool data_same) { + string draw(const net_info& net, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; auto net_sync = Config::getB("net_sync"); @@ -1148,11 +1148,11 @@ namespace Proc { return (not changed ? -1 : selected); } - string draw(const vector& plist, const bool force_redraw, const bool data_same) { + string draw(const vector& plist, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; auto proc_tree = Config::getB("proc_tree"); - const bool show_detailed = (Config::getB("show_detailed") and cmp_equal(Proc::detailed.last_pid, Config::getI("detailed_pid"))); - const bool proc_gradient = (Config::getB("proc_gradient") and not Config::getB("lowcolor") and Theme::gradients.contains("proc")); + bool show_detailed = (Config::getB("show_detailed") and cmp_equal(Proc::detailed.last_pid, Config::getI("detailed_pid"))); + bool proc_gradient = (Config::getB("proc_gradient") and not Config::getB("lowcolor") and Theme::gradients.contains("proc")); auto proc_colors = Config::getB("proc_colors"); auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_proc")); @@ -1194,7 +1194,7 @@ namespace Proc { //? Detailed box if (show_detailed) { - const bool alive = detailed.status != "Dead"; + bool alive = detailed.status != "Dead"; dgraph_x = x; dgraph_width = max(width / 3, width - 121); d_width = width - dgraph_width - 1; @@ -1347,7 +1347,7 @@ namespace Proc { //? Draw details box if shown if (show_detailed) { - const bool alive = detailed.status != "Dead"; + bool alive = detailed.status != "Dead"; const int item_fit = floor((double)(d_width - 2) / 10); const int item_width = floor((double)(d_width - 2) / min(item_fit, 8)); @@ -1406,7 +1406,7 @@ namespace Proc { } //? Update graphs for processes with above 0.0% cpu usage, delete if below 0.1% 10x times - const bool has_graph = show_graphs ? p_counters.contains(p.pid) : false; + bool has_graph = show_graphs ? p_counters.contains(p.pid) : false; if (show_graphs and ((p.cpu_p > 0 and not has_graph) or (not data_same and has_graph))) { if (not has_graph) { p_graphs[p.pid] = Draw::Graph{5, 1, "", {}, graph_symbol}; diff --git a/src/btop_draw.hpp b/src/btop_draw.hpp index 59a0e69..5fafa63 100644 --- a/src/btop_draw.hpp +++ b/src/btop_draw.hpp @@ -93,7 +93,7 @@ namespace Draw { array cache; public: Meter(); - Meter(const int width, const string& color_gradient, const bool invert = false); + Meter(const int width, const string& color_gradient, bool invert = false); //* Return a string representation of the meter with given value string operator()(int value); @@ -123,7 +123,7 @@ namespace Draw { long long max_value=0, long long offset=0); //* Add last value from back of and return string representation of graph - string& operator()(const deque& data, const bool data_same=false); + string& operator()(const deque& data, bool data_same=false); //* Return string representation of graph string& operator()(); diff --git a/src/btop_shared.cpp b/src/btop_shared.cpp index 0e597a1..1f1e5ac 100644 --- a/src/btop_shared.cpp +++ b/src/btop_shared.cpp @@ -26,7 +26,7 @@ using namespace Tools; namespace Proc { - void proc_sorter(vector& proc_vec, const string& sorting, const bool reverse, const bool tree) { + void proc_sorter(vector& proc_vec, const string& sorting, bool reverse, bool tree) { if (reverse) { switch (v_index(sort_vector, sorting)) { case 0: rng::stable_sort(proc_vec, rng::less{}, &proc_info::pid); break; @@ -70,7 +70,7 @@ namespace Proc { } } - void tree_sort(vector& proc_vec, const string& sorting, const bool reverse, int& c_index, const int index_max, const bool collapsed) { + void tree_sort(vector& proc_vec, const string& sorting, bool reverse, int& c_index, const int index_max, bool collapsed) { if (proc_vec.size() > 1) { if (reverse) { switch (v_index(sort_vector, sorting)) { @@ -99,7 +99,7 @@ namespace Proc { } void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, - int cur_depth, const bool collapsed, const string& filter, bool found, const bool no_update, const bool should_filter) { + int cur_depth, bool collapsed, const string& filter, bool found, bool no_update, bool should_filter) { auto cur_pos = out_procs.size(); bool filtering = false; diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 2fed8a7..a5f5d38 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -67,7 +67,7 @@ namespace Runner { extern bool pause_output; extern string debug_bg; - void run(const string& box="", const bool no_update=false, const bool force_redraw=false); + void run(const string& box="", bool no_update = false, bool force_redraw = false); void stop(); } @@ -115,10 +115,10 @@ namespace Cpu { }; //* Collect cpu stats and temperatures - auto collect(const bool no_update=false) -> cpu_info&; + auto collect(bool no_update = false) -> cpu_info&; //* Draw contents of cpu box using as source - string draw(const cpu_info& cpu, const bool force_redraw=false, const bool data_same=false); + string draw(const cpu_info& cpu, bool force_redraw = false, bool data_same = false); //* Parse /proc/cpu info for mapping of core ids auto get_core_mapping() -> unordered_flat_map; @@ -168,10 +168,10 @@ namespace Mem { uint64_t get_totalMem(); //* Collect mem & disks stats - auto collect(const bool no_update=false) -> mem_info&; + auto collect(bool no_update = false) -> mem_info&; //* Draw contents of mem box using as source - string draw(const mem_info& mem, const bool force_redraw=false, const bool data_same=false); + string draw(const mem_info& mem, bool force_redraw = false, bool data_same = false); } @@ -204,10 +204,10 @@ namespace Net { extern unordered_flat_map current_net; //* Collect net upload/download stats - auto collect(const bool no_update=false) -> net_info&; + auto collect(bool no_update=false) -> net_info&; //* Draw contents of net box using as source - string draw(const net_info& net, const bool force_redraw=false, const bool data_same=false); + string draw(const net_info& net, bool force_redraw = false, bool data_same = false); } namespace Proc { @@ -287,13 +287,13 @@ namespace Proc { extern detail_container detailed; //* Collect and sort process information from /proc - auto collect(const bool no_update=false) -> vector&; + auto collect(bool no_update = false) -> vector&; //* Update current selection and view, returns -1 if no change otherwise the current selection int selection(const string& cmd_key); //* Draw contents of proc box using as data source - string draw(const vector& plist, const bool force_redraw=false, const bool data_same=false); + string draw(const vector& plist, bool force_redraw = false, bool data_same = false); struct tree_proc { std::reference_wrapper entry; @@ -301,15 +301,14 @@ namespace Proc { }; //* Sort vector of proc_info's - void proc_sorter(vector& proc_vec, const string& sorting, - const bool reverse, const bool tree = false); + void proc_sorter(vector& proc_vec, const string& sorting, bool reverse, bool tree = false); //* Recursive sort of process tree void tree_sort(vector& proc_vec, const string& sorting, - const bool reverse, int& c_index, const int index_max, const bool collapsed = false); + bool reverse, int& c_index, const int index_max, bool collapsed = false); //* Generate process tree list void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, - int cur_depth, const bool collapsed, const string& filter, - bool found=false, const bool no_update=false, const bool should_filter=false); + int cur_depth, bool collapsed, const string& filter, + bool found = false, bool no_update = false, bool should_filter = false); } diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 2d4c70e..6e8becb 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -98,10 +98,10 @@ namespace Term { } auto get_min_size(const string& boxes) -> array { - const bool cpu = boxes.find("cpu") != string::npos; - const bool mem = boxes.find("mem") != string::npos; - const bool net = boxes.find("net") != string::npos; - const bool proc = boxes.find("proc") != string::npos; + bool cpu = boxes.find("cpu") != string::npos; + bool mem = boxes.find("mem") != string::npos; + bool net = boxes.find("net") != string::npos; + bool proc = boxes.find("proc") != string::npos; int width = 0; if (mem) width = Mem::min_width; else if (net) width = Mem::min_width; @@ -205,8 +205,10 @@ namespace Tools { return chars; } - string uresize(string str, const size_t len, const bool wide) { - if (len < 1 or str.empty()) return ""; + string uresize(string str, const size_t len, bool wide) { + if (len < 1 or str.empty()) + return ""; + if (wide) { try { std::wstring_convert> conv; @@ -233,8 +235,10 @@ namespace Tools { return str; } - string luresize(string str, const size_t len, const bool wide) { - if (len < 1 or str.empty()) return ""; + string luresize(string str, const size_t len, bool wide) { + if (len < 1 or str.empty()) + return ""; + for (size_t x = 0, last_pos = 0, i = str.size() - 1; i > 0 ; i--) { if (wide and static_cast(str.at(i)) > 0xef) { x += 2; @@ -484,7 +488,7 @@ namespace Tools { } atomic_lock::atomic_lock(atomic& atom, bool wait) : atom(atom) { - if (wait) while (not this->atom.compare_exchange_strong(this->not_true, true)); + if (wait) while (not this->atom.compare_exchange_strong(this->not_true, true)); else this->atom.store(true); } @@ -546,10 +550,14 @@ namespace Logger { int status = -1; public: lose_priv() { - if (geteuid() != Global::real_uid) this->status = seteuid(Global::real_uid); + if (geteuid() != Global::real_uid) { + this->status = seteuid(Global::real_uid); + } } ~lose_priv() { - if (status == 0) status = seteuid(Global::set_uid); + if (status == 0) { + status = seteuid(Global::set_uid); + } } }; @@ -566,8 +574,12 @@ namespace Logger { if (fs::exists(logfile) and fs::file_size(logfile, ec) > 1024 << 10 and not ec) { auto old_log = logfile; old_log += ".1"; - if (fs::exists(old_log)) fs::remove(old_log, ec); - if (not ec) fs::rename(logfile, old_log, ec); + + if (fs::exists(old_log)) + fs::remove(old_log, ec); + + if (not ec) + fs::rename(logfile, old_log, ec); } if (not ec) { std::ofstream lwrite(logfile, std::ios::app); diff --git a/src/btop_tools.hpp b/src/btop_tools.hpp index 52c8e65..d42c240 100644 --- a/src/btop_tools.hpp +++ b/src/btop_tools.hpp @@ -155,10 +155,10 @@ namespace Tools { } //* Resize a string consisting of UTF8 characters (only reduces size) - string uresize(const string str, const size_t len, const bool wide=false); + string uresize(const string str, const size_t len, bool wide = false); //* Resize a string consisting of UTF8 characters from left (only reduces size) - string luresize(const string str, const size_t len, const bool wide=false); + string luresize(const string str, const size_t len, bool wide = false); //* Replace in with and return new string string s_replace(const string& str, const string& from, const string& to); @@ -288,7 +288,7 @@ namespace Tools { //* bit=True or defaults to bytes //* start=int to set 1024 multiplier starting unit //* short=True always returns 0 decimals and shortens unit to 1 character - string floating_humanizer(uint64_t value, bool shorten = false, size_t start=0, bool bit = false, bool per_second = false); + string floating_humanizer(uint64_t value, bool shorten = false, size_t start = 0, bool bit = false, bool per_second = false); //* Add std::string operator * : Repeat string number of times std::string operator*(const string& str, int64_t n); diff --git a/src/freebsd/btop_collect.cpp b/src/freebsd/btop_collect.cpp index bc01333..c0d5163 100644 --- a/src/freebsd/btop_collect.cpp +++ b/src/freebsd/btop_collect.cpp @@ -385,7 +385,7 @@ namespace Cpu { return {percent, seconds, status}; } - auto collect(const bool no_update) -> cpu_info & { + auto collect(bool no_update) -> cpu_info & { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto &cpu = current_cpu; @@ -610,7 +610,7 @@ namespace Mem { } - auto collect(const bool no_update) -> mem_info & { + auto collect(bool no_update) -> mem_info & { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; @@ -618,7 +618,7 @@ namespace Mem { auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; - static const bool snapped = (getenv("BTOP_SNAPPED") != NULL); + static bool snapped = (getenv("BTOP_SNAPPED") != NULL); int mib[4]; u_int memActive, memWire, cachedMem, freeMem; @@ -803,7 +803,7 @@ namespace Net { auto operator()() -> struct ifaddrs * { return ifaddr; } }; - auto collect(const bool no_update) -> net_info & { + auto collect(bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); @@ -1078,7 +1078,7 @@ namespace Proc { }; //* Collects and sorts process information from /proc - auto collect(const bool no_update) -> vector & { + auto collect(bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); @@ -1088,7 +1088,7 @@ namespace Proc { const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; - const bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); + bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); if (sorted_change) { current_sort = sorting; current_rev = reverse; diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index b8b53f1..5bbae49 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -659,7 +659,7 @@ namespace Cpu { return {percent, seconds, status}; } - auto collect(const bool no_update) -> cpu_info& { + auto collect(bool no_update) -> cpu_info& { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto& cpu = current_cpu; @@ -806,7 +806,7 @@ namespace Mem { return totalMem; } - auto collect(const bool no_update) -> mem_info& { + auto collect(bool no_update) -> mem_info& { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; auto show_swap = Config::getB("show_swap"); auto swap_disk = Config::getB("swap_disk"); @@ -1324,7 +1324,7 @@ namespace Net { auto operator()() -> struct ifaddrs* { return ifaddr; } }; - auto collect(const bool no_update) -> net_info& { + auto collect(bool no_update) -> net_info& { auto& net = current_net; auto& config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); @@ -1612,7 +1612,7 @@ namespace Proc { } //* Collects and sorts process information from /proc - auto collect(const bool no_update) -> vector& { + auto collect(bool no_update) -> vector& { const auto& sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto& filter = Config::getS("proc_filter"); @@ -1623,7 +1623,7 @@ namespace Proc { const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; - const bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); + bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); if (sorted_change) { current_sort = sorting; current_rev = reverse; diff --git a/src/osx/btop_collect.cpp b/src/osx/btop_collect.cpp index 1ae33c4..b0f09b6 100644 --- a/src/osx/btop_collect.cpp +++ b/src/osx/btop_collect.cpp @@ -437,7 +437,7 @@ namespace Cpu { return {percent, seconds, status}; } - auto collect(const bool no_update) -> cpu_info & { + auto collect(bool no_update) -> cpu_info & { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto &cpu = current_cpu; @@ -662,7 +662,7 @@ namespace Mem { } } - auto collect(const bool no_update) -> mem_info & { + auto collect(bool no_update) -> mem_info & { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; @@ -670,7 +670,7 @@ namespace Mem { auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; - static const bool snapped = (getenv("BTOP_SNAPPED") != NULL); + static bool snapped = (getenv("BTOP_SNAPPED") != NULL); vm_statistics64 p; mach_msg_type_number_t info_size = HOST_VM_INFO64_COUNT; @@ -842,7 +842,7 @@ namespace Net { auto operator()() -> struct ifaddrs * { return ifaddr; } }; - auto collect(const bool no_update) -> net_info & { + auto collect(bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); @@ -1106,7 +1106,7 @@ namespace Proc { } //* Collects and sorts process information from /proc - auto collect(const bool no_update) -> vector & { + auto collect(bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); @@ -1116,7 +1116,7 @@ namespace Proc { const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; - const bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); + bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); if (sorted_change) { current_sort = sorting; current_rev = reverse; From 0cb31e7b11641e9625ddcad0d41c6de627179c8c Mon Sep 17 00:00:00 2001 From: aristocratos Date: Wed, 5 Oct 2022 10:41:09 +0200 Subject: [PATCH 032/209] Fixed: Cpu::collect() core count counter... --- src/linux/btop_collect.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index b8b53f1..c86926f 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -680,7 +680,7 @@ namespace Cpu { for (; i <= Shared::coreCount; i++) { //? Make sure to add zero value for missing core values if at end of file - if ((not cread.good() or cread.peek() != 'c') and i < Shared::coreCount) { + if ((not cread.good() or cread.peek() != 'c') and i <= Shared::coreCount) { if (i == 0) throw std::runtime_error("Failed to parse /proc/stat"); else cpu.core_percent.at(i-1).push_back(0); } @@ -758,9 +758,9 @@ namespace Cpu { if (i < Shared::coreCount + 1) throw std::runtime_error("Failed to parse /proc/stat"); } catch (const std::exception& e) { - Logger::debug("get_cpuHz() : " + string{e.what()}); + Logger::debug("Cpu::collect() : " + string{e.what()}); if (cread.bad()) throw std::runtime_error("Failed to read /proc/stat"); - else throw std::runtime_error("collect() : " + string{e.what()}); + else throw std::runtime_error("Cpu::collect() : " + string{e.what()}); } if (Config::getB("show_cpu_freq")) From 7a2556eae51286f8c170b4f73c03ba8ff7f97731 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Thu, 6 Oct 2022 22:16:34 +0200 Subject: [PATCH 033/209] v1.2.10 Bug fixes, cleanup + a new theme --- CHANGELOG.md | 16 ++++++++++++++++ src/btop.cpp | 2 +- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e0e8760..fc8e9e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,19 @@ +## v1.2.10 + +* Fixed: Process tree filtering not case insensitive + +* Added: Paper theme, by @s6muel + +* Fixed: Extra checks to avoid crash on trying to replace empty strings in tree mode + +* Fixed: Crashing when cores are offline + +* Fixed: Cpu::collect() core count counter... + +* Changed: Using sysconf(_SC_NPROCESSORS_CONF) for number of cores instead of sysconf(_SC_NPROCESSORS_ONLN) + +* Maintenance: Code cleanup, by @stefanos82 + ## v1.2.9 * Fixed: Memory values not clearing properly when not in graph mode in mem box diff --git a/src/btop.cpp b/src/btop.cpp index d75ef22..6df4fc7 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -73,7 +73,7 @@ namespace Global { {"#801414", "██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ╚═╝"}, {"#000000", "╚═════╝ ╚═╝ ╚═════╝ ╚═╝"}, }; - const string Version = "1.2.9"; + const string Version = "1.2.10"; int coreCount; string overlay; From e5cc895015101a2fd0160bb0816da8dff3129699 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Fri, 7 Oct 2022 13:41:04 +0200 Subject: [PATCH 034/209] Fixed: Number of cores wrongly detected for Ryzen in rare cases. --- src/linux/btop_collect.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 2d04fa5..d31cf89 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -26,6 +26,7 @@ tab-size = 4 #include #include #include +#include #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) #include @@ -106,10 +107,13 @@ namespace Shared { if (passwd_path.empty()) Logger::warning("Could not read /etc/passwd, will show UID instead of username."); - coreCount = sysconf(_SC_NPROCESSORS_CONF); + coreCount = std::thread::hardware_concurrency(); if (coreCount < 1) { - coreCount = 1; - Logger::warning("Could not determine number of cores, defaulting to 1."); + coreCount = sysconf(_SC_NPROCESSORS_CONF); + if (coreCount < 1) { + coreCount = 1; + Logger::warning("Could not determine number of cores, defaulting to 1."); + } } pageSize = sysconf(_SC_PAGE_SIZE); From 14444760c435b38202d7c85e8ce80ebabcdbf060 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Fri, 7 Oct 2022 13:52:34 +0200 Subject: [PATCH 035/209] v1.2.11 Quick fix for number of cores detection --- CHANGELOG.md | 4 ++++ src/btop.cpp | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fc8e9e6..2584889 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,7 @@ +## v1.2.11 + +* Fixed: Number of cores wrongly detected for Ryzen in rare cases. + ## v1.2.10 * Fixed: Process tree filtering not case insensitive diff --git a/src/btop.cpp b/src/btop.cpp index 6df4fc7..60fda74 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -73,7 +73,7 @@ namespace Global { {"#801414", "██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ╚═╝"}, {"#000000", "╚═════╝ ╚═╝ ╚═════╝ ╚═╝"}, }; - const string Version = "1.2.10"; + const string Version = "1.2.11"; int coreCount; string overlay; From 4f45b9b25fa1e635f255179a1fd2f53ff430a030 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Fri, 7 Oct 2022 20:45:12 +0200 Subject: [PATCH 036/209] Added: Dynamic updating of max number of CPU cores --- src/btop.cpp | 9 ++++++++ src/btop_shared.hpp | 1 + src/linux/btop_collect.cpp | 46 +++++++++++++++++++++++++++++++------- 3 files changed, 48 insertions(+), 8 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index 60fda74..f71ffc9 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -318,6 +318,7 @@ namespace Runner { atomic stopping (false); atomic waiting (false); atomic redraw (false); + atomic coreNum_reset (false); //* Setup semaphore for triggering thread to do work #if __GNUC__ < 11 @@ -475,6 +476,14 @@ namespace Runner { //? Start collect auto cpu = Cpu::collect(conf.no_update); + if (coreNum_reset) { + coreNum_reset = false; + Cpu::core_mapping = Cpu::get_core_mapping(); + Global::resized = true; + Input::interrupt = true; + continue; + } + if (Global::debug) debug_timer("cpu", draw_begin); //? Draw box diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index a5f5d38..919bc31 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -63,6 +63,7 @@ namespace Runner { extern atomic reading; extern atomic stopping; extern atomic redraw; + extern atomic coreNum_reset; extern pthread_t runner_id; extern bool pause_output; extern string debug_bg; diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index d31cf89..b2085f6 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -135,6 +135,7 @@ namespace Shared { Cpu::core_old_totals.insert(Cpu::core_old_totals.begin(), Shared::coreCount, 0); Cpu::core_old_idles.insert(Cpu::core_old_idles.begin(), Shared::coreCount, 0); Cpu::collect(); + if (Runner::coreNum_reset) Runner::coreNum_reset = false; for (auto& [field, vec] : Cpu::current_cpu.cpu_percent) { if (not vec.empty()) Cpu::available_fields.push_back(field); } @@ -681,22 +682,37 @@ namespace Cpu { string cpu_name; cread.open(Shared::procPath / "stat"); int i = 0; - for (; i <= Shared::coreCount; i++) { - + int target = Shared::coreCount; + for (; i <= target or (cread.good() and cread.peek() == 'c'); i++) { //? Make sure to add zero value for missing core values if at end of file - if ((not cread.good() or cread.peek() != 'c') and i <= Shared::coreCount) { + if ((not cread.good() or cread.peek() != 'c') and i <= target) { if (i == 0) throw std::runtime_error("Failed to parse /proc/stat"); - else cpu.core_percent.at(i-1).push_back(0); + else { + //? Fix container sizes if new cores are detected + while (cmp_less(cpu.core_percent.size(), i)) { + core_old_totals.push_back(0); + core_old_idles.push_back(0); + cpu.core_percent.push_back({}); + } + cpu.core_percent.at(i-1).push_back(0); + } } else { if (i == 0) cread.ignore(SSmax, ' '); else { cread >> cpu_name; int cpuNum = std::stoi(cpu_name.substr(3)); - if (cpuNum > Shared::coreCount - 1) throw std::runtime_error("Mismatch betweeen /proc/stat core count and previously detected core count"); + if (cpuNum >= target - 1) target = cpuNum + (cread.peek() == 'c' ? 2 : 1); + //? Add zero value for core if core number is missing from /proc/stat while (i - 1 < cpuNum) { - cpu.core_percent.at(i-1).push_back(0); + //? Fix container sizes if new cores are detected + while (cmp_less(cpu.core_percent.size(), i)) { + core_old_totals.push_back(0); + core_old_idles.push_back(0); + cpu.core_percent.push_back({}); + } + cpu.core_percent[i-1].push_back(0); if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); i++; } @@ -745,7 +761,12 @@ namespace Cpu { } //? Calculate cpu total for each core else { - if (i > Shared::coreCount) break; + //? Fix container sizes if new cores are detected + while (cmp_less(cpu.core_percent.size(), i)) { + core_old_totals.push_back(0); + core_old_idles.push_back(0); + cpu.core_percent.push_back({}); + } const long long calc_totals = max(0ll, totals - core_old_totals.at(i-1)); const long long calc_idles = max(0ll, idles - core_old_idles.at(i-1)); core_old_totals.at(i-1) = totals; @@ -759,7 +780,14 @@ namespace Cpu { if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); } - if (i < Shared::coreCount + 1) throw std::runtime_error("Failed to parse /proc/stat"); + //? Notify main thread to redraw screen if we found more cores than previously detected + if (cmp_greater(cpu.core_percent.size(), Shared::coreCount)) { + Logger::debug("Changing CPU max corecount from " + to_string(Shared::coreCount) + " to " + to_string(cpu.core_percent.size()) + "."); + Runner::coreNum_reset = true; + Shared::coreCount = cpu.core_percent.size(); + while (cmp_less(current_cpu.temp.size(), cpu.core_percent.size() + 1)) current_cpu.temp.push_back({0}); + } + } catch (const std::exception& e) { Logger::debug("Cpu::collect() : " + string{e.what()}); @@ -1329,6 +1357,7 @@ namespace Net { }; auto collect(bool no_update) -> net_info& { + if (Runner::stopping) return empty_net; auto& net = current_net; auto& config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); @@ -1617,6 +1646,7 @@ namespace Proc { //* Collects and sorts process information from /proc auto collect(bool no_update) -> vector& { + if (Runner::stopping) return current_procs; const auto& sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto& filter = Config::getS("proc_filter"); From 3dd6a6cc6b3677d01c9adf33bd579713bf1dc2fa Mon Sep 17 00:00:00 2001 From: aristocratos Date: Fri, 7 Oct 2022 20:59:47 +0200 Subject: [PATCH 037/209] v1.2.12 Bug fix --- CHANGELOG.md | 4 ++++ src/btop.cpp | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2584889..3e94474 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,7 @@ +## v1.2.12 + +* Added: Dynamic updating of max number of CPU cores. + ## v1.2.11 * Fixed: Number of cores wrongly detected for Ryzen in rare cases. diff --git a/src/btop.cpp b/src/btop.cpp index f71ffc9..6a88511 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -73,7 +73,7 @@ namespace Global { {"#801414", "██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ╚═╝"}, {"#000000", "╚═════╝ ╚═╝ ╚═════╝ ╚═╝"}, }; - const string Version = "1.2.11"; + const string Version = "1.2.12"; int coreCount; string overlay; From 080a47e6496f12f616b811e0d2f8f36c62d397e2 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Mon, 10 Oct 2022 12:29:32 +0200 Subject: [PATCH 038/209] Added: VERBOSE=true flag for Makefile to display all compiler commands and fixed so already set CXXFLAGS and LDFLAGS are displayed. --- Makefile | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index d1bc95d..6a36c76 100644 --- a/Makefile +++ b/Makefile @@ -18,6 +18,9 @@ else override PRE := info-quiet endif +OLDCXX := $(CXXFLAGS) +OLDLD := $(LDFLAGS) + PREFIX ?= /usr/local #? Detect PLATFORM and ARCH from uname/gcc if not set @@ -53,6 +56,10 @@ ifeq ($(STRIP),true) override ADDFLAGS += -s endif +ifneq ($(VERBOSE),true) + override VERBOSE := false +endif + #? Compiler and Linker ifeq ($(shell command -v g++-11 >/dev/null; echo $$?),0) CXX := g++-11 @@ -167,8 +174,8 @@ info: @printf "\033[1;91mWARNFLAGS \033[1;94m:| \033[0m$(WARNFLAGS)\n" @printf "\033[1;94mOPTFLAGS \033[1;94m:| \033[0m$(OPTFLAGS)\n" @printf "\033[1;93mLDCXXFLAGS \033[1;94m:| \033[0m$(LDCXXFLAGS)\n" - @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m)\n" - @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m)\n" + @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDCXX)\n" + @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDLD)\n" info-quiet: @sleep 0.1 2>/dev/null || true @@ -252,6 +259,7 @@ btop: $(OBJECTS) @sleep 0.2 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\n\033[1;92mLinking and optimizing binary\033[37m...\033[0m\n" + @$(VERBOSE) && printf "$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS)\n" @$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS) || exit 1 @printf "\033[1;92m100$(P) -> \033[1;37m$(TARGETDIR)/btop \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $(TARGETDIR)/btop | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" @printf "\n\033[1;92mBuild complete in \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $(TIMESTAMP) 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo "unknown")\033[92m)\033[0m\n" @@ -262,6 +270,7 @@ $(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT) @sleep 0.3 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\033[1;97mCompiling $<\033[0m\n" + @$(VERBOSE) && printf "$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $<\n" @$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $< || exit 1 @printf "\033[1;92m$$($(PROGRESS))$(P)\033[10D\033[5C-> \033[1;37m$@ \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $@ | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$($(DATE_CMD) +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" From 939062b17c8f82d08c022cbb96207447008bbd32 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Mon, 10 Oct 2022 12:34:06 +0200 Subject: [PATCH 039/209] Added more Makefile flags --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 4fc8ff3..ae3e19c 100644 --- a/README.md +++ b/README.md @@ -327,6 +327,8 @@ Also needs a UTF8 locale and a font that covers: 3. **Compile** + Append `VERBOSE=true` to display full compiler/linker commands. + Append `STATIC=true` to `make` command for static compilation. Notice! If using LDAP Authentication, usernames will show as UID number for LDAP users if compiling statically with glibc. @@ -417,6 +419,8 @@ Also needs a UTF8 locale and a font that covers: 3. **Compile** + Append `VERBOSE=true` to display full compiler/linker commands. + Append `STATIC=true` to `make` command for static compilation (only libgcc and libstdc++ will be static!). Append `QUIET=true` for less verbose output. @@ -501,6 +505,8 @@ Also needs a UTF8 locale and a font that covers: 3. **Compile** + Append `VERBOSE=true` to display full compiler/linker commands. + Append `STATIC=true` to `make` command for static compilation. Append `QUIET=true` for less verbose output. From c9b0885a3fd4e556c3031ce4f8df4acee7ec48a3 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Mon, 10 Oct 2022 12:35:30 +0200 Subject: [PATCH 040/209] Update README.md --- README.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index ae3e19c..c15f8f4 100644 --- a/README.md +++ b/README.md @@ -329,7 +329,7 @@ Also needs a UTF8 locale and a font that covers: Append `VERBOSE=true` to display full compiler/linker commands. - Append `STATIC=true` to `make` command for static compilation. + Append `STATIC=true` for static compilation. Notice! If using LDAP Authentication, usernames will show as UID number for LDAP users if compiling statically with glibc. @@ -421,7 +421,7 @@ Also needs a UTF8 locale and a font that covers: Append `VERBOSE=true` to display full compiler/linker commands. - Append `STATIC=true` to `make` command for static compilation (only libgcc and libstdc++ will be static!). + Append `STATIC=true` for static compilation (only libgcc and libstdc++ will be static!). Append `QUIET=true` for less verbose output. @@ -506,8 +506,6 @@ Also needs a UTF8 locale and a font that covers: 3. **Compile** Append `VERBOSE=true` to display full compiler/linker commands. - - Append `STATIC=true` to `make` command for static compilation. Append `QUIET=true` for less verbose output. From 2ff886441820168102588c405fbae92341f2a04d Mon Sep 17 00:00:00 2001 From: aristocratos Date: Mon, 10 Oct 2022 13:02:07 +0200 Subject: [PATCH 041/209] Makefile: Reverse VERBOSE bool to not stop with macOS make --- Makefile | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 6a36c76..4a607a1 100644 --- a/Makefile +++ b/Makefile @@ -56,8 +56,10 @@ ifeq ($(STRIP),true) override ADDFLAGS += -s endif -ifneq ($(VERBOSE),true) +ifeq ($(VERBOSE),true) override VERBOSE := false +else + override VERBOSE := true endif #? Compiler and Linker @@ -259,7 +261,7 @@ btop: $(OBJECTS) @sleep 0.2 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\n\033[1;92mLinking and optimizing binary\033[37m...\033[0m\n" - @$(VERBOSE) && printf "$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS)\n" + @$(VERBOSE) || printf "$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS)\n" @$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS) || exit 1 @printf "\033[1;92m100$(P) -> \033[1;37m$(TARGETDIR)/btop \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $(TARGETDIR)/btop | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" @printf "\n\033[1;92mBuild complete in \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $(TIMESTAMP) 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo "unknown")\033[92m)\033[0m\n" @@ -270,7 +272,7 @@ $(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT) @sleep 0.3 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\033[1;97mCompiling $<\033[0m\n" - @$(VERBOSE) && printf "$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $<\n" + @$(VERBOSE) || printf "$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $<\n" @$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $< || exit 1 @printf "\033[1;92m$$($(PROGRESS))$(P)\033[10D\033[5C-> \033[1;37m$@ \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $@ | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$($(DATE_CMD) +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" From 8a07bc43b4e3a8ccf329205ea2ef56c39e53cd1f Mon Sep 17 00:00:00 2001 From: aristocratos Date: Thu, 13 Oct 2022 09:26:06 +0200 Subject: [PATCH 042/209] Changed: Reverted back to sysconf(_SC_NPROCESSORS_ONLN) for Cpu core count ant let the new dynamic update fix if cores are turned on later --- src/linux/btop_collect.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index b2085f6..f889b6d 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -26,7 +26,6 @@ tab-size = 4 #include #include #include -#include #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) #include @@ -107,7 +106,7 @@ namespace Shared { if (passwd_path.empty()) Logger::warning("Could not read /etc/passwd, will show UID instead of username."); - coreCount = std::thread::hardware_concurrency(); + coreCount = sysconf(_SC_NPROCESSORS_ONLN); if (coreCount < 1) { coreCount = sysconf(_SC_NPROCESSORS_CONF); if (coreCount < 1) { From 7943a0234a82db824bfadb0982e37dad8c202556 Mon Sep 17 00:00:00 2001 From: daephx Date: Sat, 15 Oct 2022 18:19:50 -0700 Subject: [PATCH 043/209] fix: spelling mistake in btop.conf --- README.md | 2 +- src/btop_config.cpp | 2 +- src/btop_menu.cpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index c15f8f4..4471b82 100644 --- a/README.md +++ b/README.md @@ -622,7 +622,7 @@ force_tty = False #* Define presets for the layout of the boxes. Preset 0 is always all boxes shown with default settings. Max 9 presets. #* Format: "box_name:P:G,box_name:P:G" P=(0 or 1) for alternate positions, G=graph symbol to use for box. -#* Use withespace " " as separator between different presets. +#* Use whitespace " " as separator between different presets. #* Example: "cpu:0:default,mem:0:tty,proc:1:default cpu:0:braille,proc:0:tty" presets = "cpu:1:default,proc:0:default cpu:0:default,mem:0:default,net:0:default cpu:0:block,net:0:tty" diff --git a/src/btop_config.cpp b/src/btop_config.cpp index 8a38394..700cc44 100644 --- a/src/btop_config.cpp +++ b/src/btop_config.cpp @@ -56,7 +56,7 @@ namespace Config { {"presets", "#* Define presets for the layout of the boxes. Preset 0 is always all boxes shown with default settings. Max 9 presets.\n" "#* Format: \"box_name:P:G,box_name:P:G\" P=(0 or 1) for alternate positions, G=graph symbol to use for box.\n" - "#* Use withespace \" \" as separator between different presets.\n" + "#* Use whitespace \" \" as separator between different presets.\n" "#* Example: \"cpu:0:default,mem:0:tty,proc:1:default cpu:0:braille,proc:0:tty\""}, {"vim_keys", "#* Set to True to enable \"h,j,k,l,g,G\" keys for directional control in lists.\n" diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index c5822f2..cf2fba2 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -207,7 +207,7 @@ namespace Menu { "P=(0 or 1) for alternate positions.", "G=graph symbol to use for box.", "", - "Use withespace \" \" as separator between", + "Use whitespace \" \" as separator between", "different presets.", "", "Example:", From dda9f2589ff65c7103a91526741c41dabf06b81e Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 23 Oct 2022 19:33:04 +0200 Subject: [PATCH 044/209] Fixed: Ignore disks that fails in statvfs64() to avoid slowdowns and possible crashes. --- src/linux/btop_collect.cpp | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index f889b6d..f57b6e5 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -925,6 +925,7 @@ namespace Mem { //? Get disks stats if (show_disks) { + static vector ignore_list; double uptime = system_uptime(); auto free_priv = Config::getB("disk_free_priv"); try { @@ -997,7 +998,7 @@ namespace Mem { diskread >> dev >> mountpoint >> fstype; diskread.ignore(SSmax, '\n'); - if (v_contains(found, mountpoint)) continue; + if (v_contains(ignore_list, mountpoint) or v_contains(found, mountpoint)) continue; //? Match filter if not empty if (not filter.empty()) { @@ -1056,6 +1057,7 @@ namespace Mem { } } } + //? Remove disks no longer mounted or filtered out if (swap_disk and has_swap) found.push_back("swap"); for (auto it = disks.begin(); it != disks.end();) { @@ -1072,11 +1074,14 @@ namespace Mem { diskread.close(); //? Get disk/partition stats + bool new_ignored = false; for (auto& [mountpoint, disk] : disks) { - if (std::error_code ec; not fs::exists(mountpoint, ec)) continue; + if (std::error_code ec; not fs::exists(mountpoint, ec) or v_contains(ignore_list, mountpoint)) continue; struct statvfs64 vfs; if (statvfs64(mountpoint.c_str(), &vfs) < 0) { - Logger::warning("Failed to get disk/partition stats with statvfs() for: " + mountpoint); + Logger::warning("Failed to get disk/partition stats for mount \""+ mountpoint + "\" with statvfs64 error code: " + to_string(errno) + ". Ignoring..."); + ignore_list.push_back(mountpoint); + new_ignored = true; continue; } disk.total = vfs.f_blocks * vfs.f_frsize; @@ -1086,6 +1091,16 @@ namespace Mem { disk.free_percent = 100 - disk.used_percent; } + //? Remove any problematic disks added to the ignore_list + if (new_ignored) { + for (auto it = disks.begin(); it != disks.end();) { + if (v_contains(ignore_list, it->first)) + it = disks.erase(it); + else + it++; + } + } + //? Setup disks order in UI and add swap if enabled mem.disks_order.clear(); #ifdef SNAPPED From f05a0560db6136f180eebd4a24e3a2d0088b62df Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 23 Oct 2022 19:39:41 +0200 Subject: [PATCH 045/209] Update continuous-build-linux.yml --- .github/workflows/continuous-build-linux.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/continuous-build-linux.yml b/.github/workflows/continuous-build-linux.yml index af32d65..b7186c4 100644 --- a/.github/workflows/continuous-build-linux.yml +++ b/.github/workflows/continuous-build-linux.yml @@ -83,7 +83,7 @@ jobs: run: git config --global --add safe.directory /__w/btop/btop - name: Checkout source - uses: actions/checkout@v2 + uses: actions/checkout@v3 - name: Fix - Stopping at filesystem boundary run: git init # [fix Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set).] @@ -107,7 +107,7 @@ jobs: cp bin/btop .artifacts/$FILENAME - name: Upload artifacts - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v3 with: name: btop-${{ matrix.toolchain }} path: '.artifacts/**' From f9de2598e046e9b1c6fa71ead10554ffd7f2d79d Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 23 Oct 2022 19:41:12 +0200 Subject: [PATCH 046/209] Update continuous-build-macos.yml --- .github/workflows/continuous-build-macos.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index 2cb5e4a..a219b6a 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -20,7 +20,7 @@ jobs: runs-on: macos-11 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - name: Compile run: | make CXX=g++-11 ARCH=x86_64 STATIC=true STRIP=true @@ -28,7 +28,7 @@ jobs: mv bin/btop bin/btop-x86_64-BigSur-$GIT_HASH ls -alh bin - - uses: actions/upload-artifact@v2 + - uses: actions/upload-artifact@v3 with: name: btop-x86_64-macos-BigSur path: 'bin/*' From 2247ed3db10b26b38a064e05ead8f614ba88bc79 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 23 Oct 2022 19:51:03 +0200 Subject: [PATCH 047/209] Update continuous-build-macos.yml --- .github/workflows/continuous-build-macos.yml | 22 ++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index a219b6a..d9efad4 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -15,10 +15,8 @@ on: - '.github/workflows/*' jobs: - build-osx: - + build-macos11: runs-on: macos-11 - steps: - uses: actions/checkout@v3 - name: Compile @@ -30,5 +28,21 @@ jobs: - uses: actions/upload-artifact@v3 with: - name: btop-x86_64-macos-BigSur + name: btop-x86_64-macos11-BigSur + path: 'bin/*' + + build-macos12: + runs-on: macos-12 + steps: + - uses: actions/checkout@v3 + - name: Compile + run: | + make CXX=g++-11 ARCH=x86_64 STATIC=true STRIP=true + GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") + mv bin/btop bin/btop-x86_64-Monterey-$GIT_HASH + ls -alh bin + + - uses: actions/upload-artifact@v3 + with: + name: btop-x86_64-macos12-Monterey path: 'bin/*' From 9f0fcdd5bf9d87d0579a8363f4b9bf570e669f07 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Thu, 27 Oct 2022 15:09:00 +0200 Subject: [PATCH 048/209] Fixed: Moved up get_cpuHz() in the execution order to get better cpu clock reading. --- src/linux/btop_collect.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index f57b6e5..7bc1f93 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -667,6 +667,9 @@ namespace Cpu { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto& cpu = current_cpu; + if (Config::getB("show_cpu_freq")) + cpuHz = get_cpuHz(); + ifstream cread; try { @@ -794,9 +797,6 @@ namespace Cpu { else throw std::runtime_error("Cpu::collect() : " + string{e.what()}); } - if (Config::getB("show_cpu_freq")) - cpuHz = get_cpuHz(); - if (Config::getB("check_temp") and got_sensors) update_sensors(); From a201944dc740742cd8845c7785b476cb8e936f2a Mon Sep 17 00:00:00 2001 From: aristocratos Date: Fri, 28 Oct 2022 22:33:16 +0200 Subject: [PATCH 049/209] Added autodetection for gcc12 to make compiling on macos Ventura easier. --- Makefile | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 4a607a1..ec9f90a 100644 --- a/Makefile +++ b/Makefile @@ -63,7 +63,9 @@ else endif #? Compiler and Linker -ifeq ($(shell command -v g++-11 >/dev/null; echo $$?),0) +ifeq ($(shell command -v g++-12 >/dev/null; echo $$?),0) + CXX := g++-12 +else ifeq ($(shell command -v g++-11 >/dev/null; echo $$?),0) CXX := g++-11 else ifeq ($(shell command -v g++11 >/dev/null; echo $$?),0) CXX := g++11 From f946a764c5bde79ca88bf0e38621c773d72ca34a Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Fri, 28 Oct 2022 22:36:24 +0200 Subject: [PATCH 050/209] macOS Ventura compile instructions --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index c15f8f4..5758031 100644 --- a/README.md +++ b/README.md @@ -399,6 +399,8 @@ Also needs a UTF8 locale and a font that covers: ## Compilation macOS OSX Needs GCC 10 or higher, (GCC 11 or above strongly recommended for better CPU efficiency in the compiled binary). + + GCC 12 needed for macOS Ventura. If you get linker errors on Ventura you'll need to upgrade your command line tools (Version 14.0) is bugged. The makefile also needs GNU coreutils and `sed`. From f8c272c00f0447703340e4c00ffde1dc893fc0eb Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Fri, 28 Oct 2022 22:37:53 +0200 Subject: [PATCH 051/209] macOS Ventura compile instructions --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 5758031..5d53fb4 100644 --- a/README.md +++ b/README.md @@ -409,7 +409,7 @@ Also needs a UTF8 locale and a font that covers: 1. **Install dependencies (example for Homebrew)** ``` bash - brew install coreutils make gcc@11 + brew install coreutils make gcc@12 ``` 2. **Clone repository** From ede7d0a76aadbfb94ab868b738130d8f371d409b Mon Sep 17 00:00:00 2001 From: Arjun P Date: Fri, 28 Oct 2022 22:20:29 +0100 Subject: [PATCH 052/209] proc tree view: if there's more than 40 width left, try to print full cmd --- src/btop_draw.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index bc550fd..48a434d 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1473,8 +1473,8 @@ namespace Proc { out += c_color + uresize(p.name, width_left - 1) + end + ' '; width_left -= (ulen(p.name) + 1); } - if (width_left > 7 and p.short_cmd != p.name) { - out += g_color + '(' + uresize(p.short_cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; + if (width_left > 30 || (width_left > 7 && p.short_cmd != p.name)) { + out += g_color + '(' + uresize(width_left > 30 ? p.cmd : p.short_cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; width_left -= (ulen(p.short_cmd, true) + 3); } out += string(max(0, width_left), ' ') + Mv::to(y+2+lc, x+2+tree_size); From 4fbda9df29f97b1762f68112f50b7f1e1817097f Mon Sep 17 00:00:00 2001 From: Arjun P Date: Sat, 29 Oct 2022 00:20:11 +0100 Subject: [PATCH 053/209] proc tree: fix width threshold to match commit message and use and/or instead of &&, || --- src/btop_draw.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 48a434d..4ea14f9 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1473,8 +1473,8 @@ namespace Proc { out += c_color + uresize(p.name, width_left - 1) + end + ' '; width_left -= (ulen(p.name) + 1); } - if (width_left > 30 || (width_left > 7 && p.short_cmd != p.name)) { - out += g_color + '(' + uresize(width_left > 30 ? p.cmd : p.short_cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; + if (width_left > 40 or (width_left > 7 and p.short_cmd != p.name)) { + out += g_color + '(' + uresize(width_left > 40 ? p.cmd : p.short_cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; width_left -= (ulen(p.short_cmd, true) + 3); } out += string(max(0, width_left), ' ') + Mv::to(y+2+lc, x+2+tree_size); From bb40de64c9ea3962bcda483a1af5ab5a69edfc48 Mon Sep 17 00:00:00 2001 From: Arjun P Date: Sun, 30 Oct 2022 09:27:56 +0000 Subject: [PATCH 054/209] Fix bug in proc_tree view when showing full cmd --- src/btop_draw.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 4ea14f9..099a1aa 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1473,9 +1473,12 @@ namespace Proc { out += c_color + uresize(p.name, width_left - 1) + end + ' '; width_left -= (ulen(p.name) + 1); } - if (width_left > 40 or (width_left > 7 and p.short_cmd != p.name)) { - out += g_color + '(' + uresize(width_left > 40 ? p.cmd : p.short_cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; - width_left -= (ulen(p.short_cmd, true) + 3); + if (width_left > 7) { + const string& cmd = width_left > 40 ? p.cmd : p.short_cmd; + if (not cmd.empty() and cmd != p.name) { + out += g_color + '(' + uresize(cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; + width_left -= (ulen(cmd, true) + 3); + } } out += string(max(0, width_left), ' ') + Mv::to(y+2+lc, x+2+tree_size); } From c1675634ef8f90494bb55b2747a13fff3bc47bf3 Mon Sep 17 00:00:00 2001 From: Arjun P Date: Mon, 31 Oct 2022 21:42:34 +0000 Subject: [PATCH 055/209] Address comment --- src/btop_draw.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 099a1aa..4ecd294 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1474,7 +1474,7 @@ namespace Proc { width_left -= (ulen(p.name) + 1); } if (width_left > 7) { - const string& cmd = width_left > 40 ? p.cmd : p.short_cmd; + const string& cmd = width_left > 40 ? rtrim(p.cmd) : p.short_cmd; if (not cmd.empty() and cmd != p.name) { out += g_color + '(' + uresize(cmd, width_left - 3, p_wide_cmd[p.pid]) + ") "; width_left -= (ulen(cmd, true) + 3); From eec1999a8f69ffe81f20e1daa7b15dc68eb6ac82 Mon Sep 17 00:00:00 2001 From: correabuscar Date: Fri, 4 Nov 2022 01:42:03 +0100 Subject: [PATCH 056/209] Show the first IP of the interface in NET box ... instead of the last. Also, indented the `for` statement with tabs rather than spaces. Closes #456 --- src/linux/btop_collect.cpp | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 7bc1f93..f35e6ec 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -1393,27 +1393,35 @@ namespace Net { string ipv4, ipv6; //? Iteration over all items in getifaddrs() list - for (auto* ifa = if_wrap(); ifa != NULL; ifa = ifa->ifa_next) { + for (auto* ifa = if_wrap(); ifa != NULL; ifa = ifa->ifa_next) { if (ifa->ifa_addr == NULL) continue; family = ifa->ifa_addr->sa_family; const auto& iface = ifa->ifa_name; - //? Get IPv4 address - if (family == AF_INET) { - if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv4 = ip; - } - //? Get IPv6 address - else if (family == AF_INET6) { - if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv6 = ip; - } - //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); + + // An interface can have more than one IP of the same family associated with it, + // but we pick only the first one to show in the NET box. + // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! + net[iface].ipv4.clear(); + net[iface].ipv6.clear(); } + + //? Get IPv4 address + if (family == AF_INET) { + if (net[iface].ipv4.empty() and + getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) + net[iface].ipv4 = ip; + } + //? Get IPv6 address + else if (family == AF_INET6) { + if (net[iface].ipv6.empty() and + getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) + net[iface].ipv6 = ip; + } //else, ignoring family==AF_PACKET (see man 3 getifaddrs) which is the first one in the `for` loop. } //? Get total recieved and transmitted bytes + device address if no ip was found From 96a22b40787d8587a2a217daa627a325c072edc9 Mon Sep 17 00:00:00 2001 From: correabuscar Date: Fri, 4 Nov 2022 04:49:12 +0100 Subject: [PATCH 057/209] use inet_ntop instead of getnameinfo saves 979 bytes of reserved buffer because: NI_MAXHOST is 1025 bytes and INET6_ADDRSTRLEN is 46 Depends on PR #457 being merged first. --- src/linux/btop_collect.cpp | 38 +++++++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index f35e6ec..11e6430 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -26,6 +26,8 @@ tab-size = 4 #include #include #include +#include // for inet_ntop() + #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) #include @@ -1388,7 +1390,13 @@ namespace Net { return empty_net; } int family = 0; - char ip[NI_MAXHOST]; + static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. +#if defined(IPBUFFER_MAXSIZE) +#error Overwriting a previous macro with the same name: IPBUFFER_MAXSIZE, this means you likely need to rename this one here! +#else +#define IPBUFFER_MAXSIZE (INET6_ADDRSTRLEN) // manually using the known biggest value, guarded by the above static_assert +#endif + char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; @@ -1410,19 +1418,35 @@ namespace Net { net[iface].ipv6.clear(); } + //? Get IPv4 address if (family == AF_INET) { - if (net[iface].ipv4.empty() and - getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv4 = ip; + if (net[iface].ipv4.empty()) { + if (NULL != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { + net[iface].ipv4 = ip; + } else { + int errsv = errno; + Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); + } + } } //? Get IPv6 address else if (family == AF_INET6) { - if (net[iface].ipv6.empty() and - getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv6 = ip; + if (net[iface].ipv6.empty()) { + if (NULL != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { + net[iface].ipv6 = ip; + } else { + int errsv = errno; + Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); + } + } } //else, ignoring family==AF_PACKET (see man 3 getifaddrs) which is the first one in the `for` loop. } +#if defined(IPBUFFER_MAXSIZE) +#undef IPBUFFER_MAXSIZE +#else +#error whoa, the programmer forgot something, eg. was this renamed? +#endif //? Get total recieved and transmitted bytes + device address if no ip was found for (const auto& iface : interfaces) { From bad9bbc160859b43764e6bb7886eb9a222058a0c Mon Sep 17 00:00:00 2001 From: correabuscar Date: Fri, 4 Nov 2022 10:44:22 +0100 Subject: [PATCH 058/209] make IPBUFFER_MAXSIZE an enum constant ... instead of a macro constant(which made the code less readable!) Supposedly it also doesn't use run-time storage. --- src/linux/btop_collect.cpp | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 11e6430..282ab1b 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -1391,11 +1391,7 @@ namespace Net { } int family = 0; static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. -#if defined(IPBUFFER_MAXSIZE) -#error Overwriting a previous macro with the same name: IPBUFFER_MAXSIZE, this means you likely need to rename this one here! -#else -#define IPBUFFER_MAXSIZE (INET6_ADDRSTRLEN) // manually using the known biggest value, guarded by the above static_assert -#endif + enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; @@ -1442,11 +1438,6 @@ namespace Net { } } //else, ignoring family==AF_PACKET (see man 3 getifaddrs) which is the first one in the `for` loop. } -#if defined(IPBUFFER_MAXSIZE) -#undef IPBUFFER_MAXSIZE -#else -#error whoa, the programmer forgot something, eg. was this renamed? -#endif //? Get total recieved and transmitted bytes + device address if no ip was found for (const auto& iface : interfaces) { From 68f7d1f4bb1bfc79a8c765a303606cc8d09472e3 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sat, 5 Nov 2022 22:56:52 +0100 Subject: [PATCH 059/209] Fixed: Not picking up last username from /etc/passwd --- src/linux/btop_collect.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 282ab1b..fd90588 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -1744,6 +1744,7 @@ namespace Proc { getline(pread, r_user, ':'); pread.ignore(SSmax, ':'); getline(pread, r_uid, ':'); + if (uid_user.contains(r_uid)) break; uid_user[r_uid] = r_user; pread.ignore(SSmax, '\n'); } From f05bc65c3a0b7660976523028c4843aaa224af08 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 03:04:47 +0100 Subject: [PATCH 060/209] Add actions run for pull requests (linux) [skip actions] --- .github/workflows/continuous-build-linux.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.github/workflows/continuous-build-linux.yml b/.github/workflows/continuous-build-linux.yml index b7186c4..ab99798 100644 --- a/.github/workflows/continuous-build-linux.yml +++ b/.github/workflows/continuous-build-linux.yml @@ -14,6 +14,16 @@ on: - 'include/**' - 'Makefile' - '.github/workflows/continuous-build.yml' + pull_request: + branches: + - main + paths: + - 'src/**' + - '!src/osx/**' + - '!src/freebsd/**' + - 'include/**' + - 'Makefile' + - '.github/workflows/continuous-build.yml' jobs: static-build: From 899831e4caaad7c9310ea71f5ea47e9bef7d0597 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 03:07:40 +0100 Subject: [PATCH 061/209] Add actions run for pull requests (macos) [skip actions] --- .github/workflows/continuous-build-macos.yml | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index d9efad4..3c322a4 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -12,7 +12,17 @@ on: - '!src/freebsd/**' - 'include/**' - 'Makefile' - - '.github/workflows/*' + - '.github/workflows/continuous-build-macos.yml' + pull_request: + branches: + - main + paths: + - 'src/**' + - '!src/linux/**' + - '!src/freebsd/**' + - 'include/**' + - 'Makefile' + - '.github/workflows/continuous-build-macos.yml' jobs: build-macos11: From 3a920b4e3c056e4f147141290ad0f1f89c835f75 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 03:39:53 +0100 Subject: [PATCH 062/209] Create continuous-build-freebsd.yml --- .../workflows/continuous-build-freebsd.yml | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 .github/workflows/continuous-build-freebsd.yml diff --git a/.github/workflows/continuous-build-freebsd.yml b/.github/workflows/continuous-build-freebsd.yml new file mode 100644 index 0000000..771161c --- /dev/null +++ b/.github/workflows/continuous-build-freebsd.yml @@ -0,0 +1,45 @@ +name: Continuous Build FreeBSD + +on: + workflow_dispatch: + push: + branches: + - main + tags-ignore: + - '*.*' + paths: + - 'src/**' + - '!src/linux/**' + - '!src/osx/**' + - 'include/**' + - 'Makefile' + - '.github/workflows/continuous-build-freebsd.yml' + pull_request: + branches: + - main + paths: + - 'src/**' + - '!src/linux/**' + - '!src/osx/**' + - 'include/**' + - 'Makefile' + - '.github/workflows/continuous-build-freebsd.yml' + +jobs: + build-freebsd: + runs-on: macos-12 + steps: + - uses: actions/checkout@v3 + - name: Compile + uses: vmactions/freebsd-vm@v0 + with: + release: 13.1 + prepare: | + pkg install -y gmake gcc11 coreutils git + run: | + gmake + - uses: actions/upload-artifact@v3 + with: + name: btop-x86_64-FreeBSD-13.1 + path: 'bin/btop' + From f6de85534c6a9bbd1594988de4b2f437d0aafce3 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 03:50:01 +0100 Subject: [PATCH 063/209] Update continuous-build-macos.yml --- .github/workflows/continuous-build-macos.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index 3c322a4..fe23f3b 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -1,6 +1,7 @@ name: Continuous Build MacOS on: + workflow_dispatch: push: branches: - main From 511c3a665c43f01569019d7ccd0863c643665e52 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 04:03:37 +0100 Subject: [PATCH 064/209] Update continuous-build-freebsd.yml --- .github/workflows/continuous-build-freebsd.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/continuous-build-freebsd.yml b/.github/workflows/continuous-build-freebsd.yml index 771161c..0c49f8f 100644 --- a/.github/workflows/continuous-build-freebsd.yml +++ b/.github/workflows/continuous-build-freebsd.yml @@ -38,8 +38,11 @@ jobs: pkg install -y gmake gcc11 coreutils git run: | gmake + GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") + mv bin/btop bin/btop-$GIT_HASH + ls -alh bin - uses: actions/upload-artifact@v3 with: name: btop-x86_64-FreeBSD-13.1 - path: 'bin/btop' + path: 'bin/*' From 64c9e85252c122fe55c1acaae23bfe305a827660 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 04:19:50 +0100 Subject: [PATCH 065/209] Use sh instead of csh --- .github/workflows/continuous-build-freebsd.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/continuous-build-freebsd.yml b/.github/workflows/continuous-build-freebsd.yml index 0c49f8f..95c2db6 100644 --- a/.github/workflows/continuous-build-freebsd.yml +++ b/.github/workflows/continuous-build-freebsd.yml @@ -34,6 +34,7 @@ jobs: uses: vmactions/freebsd-vm@v0 with: release: 13.1 + usesh: true prepare: | pkg install -y gmake gcc11 coreutils git run: | From 16ce8d21b151db87ec14d1c7f09a0d8eb6357ba0 Mon Sep 17 00:00:00 2001 From: correabuscar Date: Sun, 6 Nov 2022 08:17:38 +0100 Subject: [PATCH 066/209] FreeBSD: use the first IP of the interface ... instead of the last. Side effect of this is that it also detects when the current IP gets removed from the interface, instead of keep displaying the old IP. This is PR #457 but for FreeBSD, not Linux. --- src/freebsd/btop_collect.cpp | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/src/freebsd/btop_collect.cpp b/src/freebsd/btop_collect.cpp index c0d5163..f6d51b2 100644 --- a/src/freebsd/btop_collect.cpp +++ b/src/freebsd/btop_collect.cpp @@ -19,9 +19,10 @@ tab-size = 4 #include #include #include -#include #include +// man 3 getifaddrs: "BUGS: If both and are being included, must be included before " #include +#include #include #include #include @@ -829,22 +830,30 @@ namespace Net { if (ifa->ifa_addr == NULL) continue; family = ifa->ifa_addr->sa_family; const auto &iface = ifa->ifa_name; - //? Get IPv4 address - if (family == AF_INET) { - if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv4 = ip; - } - //? Get IPv6 address - // else if (family == AF_INET6) { - // if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - // net[iface].ipv6 = ip; - // } - //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); + + // An interface can have more than one IP of the same family associated with it, + // but we pick only the first one to show in the NET box. + // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! + net[iface].ipv4.clear(); + net[iface].ipv6.clear(); } + //? Get IPv4 address + if (family == AF_INET) { + if (net[iface].ipv4.empty() and + getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) + net[iface].ipv4 = ip; + } + //? Get IPv6 address + // else if (family == AF_INET6) { + // if (net[iface].ipv6.empty() and + // getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) + // net[iface].ipv6 = ip; + // } + } unordered_flat_map> ifstats; From 5d9097d9b98b703c08e4301c3e8cfa7724f9171e Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 10:04:55 +0100 Subject: [PATCH 067/209] Use gcc12 for macos12 --- .github/workflows/continuous-build-macos.yml | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index fe23f3b..cdc24c5 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -45,10 +45,14 @@ jobs: build-macos12: runs-on: macos-12 steps: - - uses: actions/checkout@v3 + - name: Install GCC12 + run: | + brew install gcc@12 + + - uses: actions/checkout@v3 - name: Compile run: | - make CXX=g++-11 ARCH=x86_64 STATIC=true STRIP=true + make CXX=g++-12 ARCH=x86_64 STATIC=true STRIP=true GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") mv bin/btop bin/btop-x86_64-Monterey-$GIT_HASH ls -alh bin From 06ba66b5ed4882622493d023791c3d87852da128 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 10:18:04 +0100 Subject: [PATCH 068/209] Possible fix for broken xcode command line tools --- .github/workflows/continuous-build-macos.yml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index cdc24c5..380170c 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -45,9 +45,14 @@ jobs: build-macos12: runs-on: macos-12 steps: - - name: Install GCC12 + - uses: maxim-lobanov/setup-xcode@v1 + with: + xcode-version: latest-stable + + - name: Install GCC12 and check Xcode version run: | brew install gcc@12 + xcodebuild --version - uses: actions/checkout@v3 - name: Compile From 83c034a04118f1a89e5e018a8fb95b681afd047c Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 10:21:01 +0100 Subject: [PATCH 069/209] Removed bad line and gcc12 install since gcc12 i preinstalled --- .github/workflows/continuous-build-macos.yml | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/.github/workflows/continuous-build-macos.yml b/.github/workflows/continuous-build-macos.yml index 380170c..a593a46 100644 --- a/.github/workflows/continuous-build-macos.yml +++ b/.github/workflows/continuous-build-macos.yml @@ -47,12 +47,7 @@ jobs: steps: - uses: maxim-lobanov/setup-xcode@v1 with: - xcode-version: latest-stable - - - name: Install GCC12 and check Xcode version - run: | - brew install gcc@12 - xcodebuild --version + xcode-version: latest-stable - uses: actions/checkout@v3 - name: Compile From c039f36bb7b4c021eb5b3fb39283d36d3131e14a Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 10:34:05 +0100 Subject: [PATCH 070/209] Added "Continuous Build FreeBSD" badge --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5302973..3ad5773 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,7 @@ [![btop](https://snapcraft.io/btop/badge.svg)](https://snapcraft.io/btop) [![Continuous Build Linux](https://github.com/aristocratos/btop/actions/workflows/continuous-build-linux.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-linux.yml) [![Continuous Build macOS](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) +[![Continuous Build FreeBSD](https://github.com/aristocratos/btop/actions/workflows/continuous-build-freebsd.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-freebsd.yml) ## Index From bd7018ed9685c5f342bc6dd7204019f79bc9aa28 Mon Sep 17 00:00:00 2001 From: correabuscar Date: Sun, 6 Nov 2022 08:36:06 +0100 Subject: [PATCH 071/209] OSX: use the first IP of the interface ...instead of the last. Side effect of this is that it also detects when the current IP gets removed from the interface, instead of keep displaying the old IP. This is PR #457 but for OSX, not Linux. --- src/osx/btop_collect.cpp | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/src/osx/btop_collect.cpp b/src/osx/btop_collect.cpp index b0f09b6..65a3f1a 100644 --- a/src/osx/btop_collect.cpp +++ b/src/osx/btop_collect.cpp @@ -19,7 +19,6 @@ tab-size = 4 #include #include #include -#include #include #include #include @@ -28,7 +27,12 @@ tab-size = 4 #include #include #include +// BUGS +// If both and are being included, must be +// included before . +// from: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/getifaddrs.3.html #include +#include #include #include #include @@ -868,21 +872,27 @@ namespace Net { if (ifa->ifa_addr == NULL) continue; family = ifa->ifa_addr->sa_family; const auto &iface = ifa->ifa_name; - //? Get IPv4 address - if (family == AF_INET) { - if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv4 = ip; - } - //? Get IPv6 address - else if (family == AF_INET6) { - if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv6 = ip; - } - //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); + // An interface can have more than one IP of the same family associated with it, + // but we pick only the first one to show in the NET box. + // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! + net[iface].ipv4.clear(); + net[iface].ipv6.clear(); + } + //? Get IPv4 address + if (family == AF_INET) { + if (net[iface].ipv4.empty() and + getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) + net[iface].ipv4 = ip; + } + //? Get IPv6 address + else if (family == AF_INET6) { + if (net[iface].ipv6.empty() and + getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) + net[iface].ipv6 = ip; } } From c52206610dc17dc4217bf4d4059aaff24e8454a6 Mon Sep 17 00:00:00 2001 From: "Jakob P. Liljenberg" Date: Sun, 6 Nov 2022 11:07:27 +0100 Subject: [PATCH 072/209] Add git config safe-directory inside freebsd vm --- .github/workflows/continuous-build-freebsd.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/continuous-build-freebsd.yml b/.github/workflows/continuous-build-freebsd.yml index 95c2db6..c920cd4 100644 --- a/.github/workflows/continuous-build-freebsd.yml +++ b/.github/workflows/continuous-build-freebsd.yml @@ -37,6 +37,7 @@ jobs: usesh: true prepare: | pkg install -y gmake gcc11 coreutils git + git config --global --add safe.directory /Users/runner/work/btop/btop run: | gmake GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") From 5a53fb4a2ce8d869733c4bf1c76bf9e8b8400297 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 6 Nov 2022 11:32:17 +0100 Subject: [PATCH 073/209] Fixed: Process nice value underflowing, issue #461 --- src/btop_shared.hpp | 2 +- src/linux/btop_collect.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 919bc31..f9275a4 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -262,7 +262,7 @@ namespace Proc { double cpu_p{}; // defaults to = 0.0 double cpu_c{}; // defaults to = 0.0 char state = '0'; - uint64_t p_nice{}; // defaults to 0 + int64_t p_nice{}; // defaults to 0 uint64_t ppid{}; // defaults to 0 uint64_t cpu_s{}; // defaults to 0 uint64_t cpu_t{}; // defaults to 0 diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index fd90588..cec781d 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -1884,7 +1884,7 @@ namespace Proc { next_x = 19; continue; case 19: //? Nice value - new_proc.p_nice = stoull(short_str); + new_proc.p_nice = stoll(short_str); continue; case 20: //? Number of threads new_proc.threads = stoull(short_str); From 12def527cd08192fd957768ca9c42765bdd3413b Mon Sep 17 00:00:00 2001 From: correabuscar Date: Sun, 6 Nov 2022 11:36:22 +0100 Subject: [PATCH 074/209] FreeBSD: replace getnameinfo with inet_ntop also make IPv6 work. --- src/freebsd/btop_collect.cpp | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/src/freebsd/btop_collect.cpp b/src/freebsd/btop_collect.cpp index f6d51b2..34d04bf 100644 --- a/src/freebsd/btop_collect.cpp +++ b/src/freebsd/btop_collect.cpp @@ -27,6 +27,7 @@ tab-size = 4 #include #include #include +#include // for inet_ntop stuff #include #include #include @@ -821,7 +822,9 @@ namespace Net { return empty_net; } int family = 0; - char ip[NI_MAXHOST]; + static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. + enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert + char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; @@ -843,17 +846,27 @@ namespace Net { } //? Get IPv4 address if (family == AF_INET) { - if (net[iface].ipv4.empty() and - getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv4 = ip; + if (net[iface].ipv4.empty()) { + if (NULL != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { + + net[iface].ipv4 = ip; + } else { + int errsv = errno; + Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); + } + } } //? Get IPv6 address - // else if (family == AF_INET6) { - // if (net[iface].ipv6.empty() and - // getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - // net[iface].ipv6 = ip; - // } - + else if (family == AF_INET6) { + if (net[iface].ipv6.empty()) { + if (NULL != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { + net[iface].ipv6 = ip; + } else { + int errsv = errno; + Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); + } + } + } } unordered_flat_map> ifstats; From 7ff3c7f7d0198722c304cb0b08a1eefa9bcdaf8c Mon Sep 17 00:00:00 2001 From: correabuscar Date: Sun, 6 Nov 2022 13:45:13 +0100 Subject: [PATCH 075/209] a comment about AF_LINK being ignored on purpose --- src/freebsd/btop_collect.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/freebsd/btop_collect.cpp b/src/freebsd/btop_collect.cpp index 34d04bf..613e996 100644 --- a/src/freebsd/btop_collect.cpp +++ b/src/freebsd/btop_collect.cpp @@ -866,7 +866,7 @@ namespace Net { Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); } } - } + } //else, ignoring family==AF_LINK (see man 3 getifaddrs) } unordered_flat_map> ifstats; From f4eea3f3cf6d47132707da194cbac3ef35be49ac Mon Sep 17 00:00:00 2001 From: correabuscar Date: Sun, 6 Nov 2022 14:36:03 +0100 Subject: [PATCH 076/209] osx: replace getnameinfo with inet_ntop this is like PR #462 for FreeBSD, and like PR #458 for Linux. --- src/osx/btop_collect.cpp | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/src/osx/btop_collect.cpp b/src/osx/btop_collect.cpp index 65a3f1a..08e80d0 100644 --- a/src/osx/btop_collect.cpp +++ b/src/osx/btop_collect.cpp @@ -41,6 +41,7 @@ tab-size = 4 #include #include #include +#include // for inet_ntop #include #include @@ -863,7 +864,9 @@ namespace Net { return empty_net; } int family = 0; - char ip[NI_MAXHOST]; + static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. + enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert + char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; @@ -884,16 +887,26 @@ namespace Net { } //? Get IPv4 address if (family == AF_INET) { - if (net[iface].ipv4.empty() and - getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv4 = ip; + if (net[iface].ipv4.empty()) { + if (NULL != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { + net[iface].ipv4 = ip; + } else { + int errsv = errno; + Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); + } + } } //? Get IPv6 address else if (family == AF_INET6) { - if (net[iface].ipv6.empty() and - getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6), ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) - net[iface].ipv6 = ip; - } + if (net[iface].ipv6.empty()) { + if (NULL != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { + net[iface].ipv6 = ip; + } else { + int errsv = errno; + Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface " + string(iface) + ", errno: " + strerror(errsv)); + } + } + } // else, ignoring family==AF_LINK (see man 3 getifaddrs) } unordered_flat_map> ifstats; From 0f8498fa4e68e3af36a50b1d9f97b931b41b0824 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sun, 6 Nov 2022 22:36:34 +0100 Subject: [PATCH 077/209] v1.2.13 Bug fixes --- CHANGELOG.md | 26 ++++++++++++++++++++++++++ src/btop.cpp | 2 +- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e94474..2a4eceb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,29 @@ +## v1.2.13 + +* Makefile: VERBOSE=true flag for Makefile to display all compiler commands and fixed so already set CXXFLAGS and LDFLAGS are displayed. + +* Makefile: Added autodetection for gcc12 to make compiling on macos Ventura easier. + +* Changed: Reverted back to sysconf(_SC_NPROCESSORS_ONLN) for Cpu core count ant let the new dynamic update fix if cores are turned on later + +* Fixed: Ignore disks that fails in statvfs64() to avoid slowdowns and possible crashes. + +* Fixed: Moved up get_cpuHz() in the execution order to get better cpu clock reading. + +* Added: proc tree view: if there's more than 40 width left, try to print full cmd, by @Superty + +* Fixed: Show the first IP of the interface in NET box instead of the last, by @correabuscar + +* Changed: Replace getnameinfo with inet_ntop [on Linux], by @correabuscar + +* Fixed: Not picking up last username from /etc/passwd + +* Fixed: Process nice value underflowing, issue #461 + +* Changed: Replace getnameinfo with inet_ntop [on FreeBSD], by @correabuscar + +* Changed: Replace getnameinfo with inet_ntop [on macos], by @correabuscar + ## v1.2.12 * Added: Dynamic updating of max number of CPU cores. diff --git a/src/btop.cpp b/src/btop.cpp index 6a88511..225abd4 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -73,7 +73,7 @@ namespace Global { {"#801414", "██████╔╝ ██║ ╚██████╔╝██║ ╚═╝ ╚═╝"}, {"#000000", "╚═════╝ ╚═╝ ╚═════╝ ╚═╝"}, }; - const string Version = "1.2.12"; + const string Version = "1.2.13"; int coreCount; string overlay; From 9aaffd6b26c4502167b1a83582516e82128da093 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Wed, 30 Nov 2022 22:41:08 +0100 Subject: [PATCH 078/209] Fixed: Use MemFree for used mem calculation if MemAvailable is greater than MemTotal. --- src/linux/btop_collect.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index cec781d..997e194 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -901,7 +901,8 @@ namespace Mem { mem.stats.at("cached") += arc_size; mem.stats.at("available") += arc_size; } - mem.stats.at("used") = totalMem - mem.stats.at("available"); + mem.stats.at("used") = totalMem - (mem.stats.at("available") <= totalMem ? mem.stats.at("available") : mem.stats.at("free")); + if (mem.stats.at("used")) if (mem.stats.at("swap_total") > 0) mem.stats.at("swap_used") = mem.stats.at("swap_total") - mem.stats.at("swap_free"); } else From e67a35df08bc576a164e2f9e95804c8980982fb3 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Wed, 30 Nov 2022 23:18:04 +0100 Subject: [PATCH 079/209] Removed unused statement... --- src/linux/btop_collect.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 997e194..62a5c62 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -902,7 +902,7 @@ namespace Mem { mem.stats.at("available") += arc_size; } mem.stats.at("used") = totalMem - (mem.stats.at("available") <= totalMem ? mem.stats.at("available") : mem.stats.at("free")); - if (mem.stats.at("used")) + if (mem.stats.at("swap_total") > 0) mem.stats.at("swap_used") = mem.stats.at("swap_total") - mem.stats.at("swap_free"); } else From 0d17fb66c45aa532a26e0e9a3b179d1f57bf037f Mon Sep 17 00:00:00 2001 From: NexAdn Date: Thu, 15 Dec 2022 10:04:33 +0100 Subject: [PATCH 080/209] Makefile: make build targets depend on directories Since directory creation is a requirement for writing the built artifacts, this commit introduces a dependency on the directories for all build targets (compile and link), so parallel builds can't fail because a build target is executed before the directories target. Closes: https://github.com/aristocratos/btop/issues/479 --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index ec9f90a..a52929c 100644 --- a/Makefile +++ b/Makefile @@ -259,7 +259,7 @@ uninstall: #? Link .ONESHELL: -btop: $(OBJECTS) +btop: $(OBJECTS) | directories @sleep 0.2 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\n\033[1;92mLinking and optimizing binary\033[37m...\033[0m\n" @@ -270,7 +270,7 @@ btop: $(OBJECTS) #? Compile .ONESHELL: -$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT) +$(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT) | directories @sleep 0.3 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\033[1;97mCompiling $<\033[0m\n" From c4ee41ebc0f7fabbf4717450c889292464dbeb6d Mon Sep 17 00:00:00 2001 From: aristocratos Date: Thu, 15 Dec 2022 17:42:07 +0100 Subject: [PATCH 081/209] Fixed: Makefile, VERBOSE flag now shows directory creation, Issue #480 --- Makefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Makefile b/Makefile index a52929c..c746c00 100644 --- a/Makefile +++ b/Makefile @@ -200,7 +200,9 @@ help: #? Make the Directories directories: + @$(VERBOSE) || printf "mkdir -p $(TARGETDIR)\n" @mkdir -p $(TARGETDIR) + @$(VERBOSE) || printf "mkdir -p $(BUILDDIR)/$(PLATFORM_DIR)\n" @mkdir -p $(BUILDDIR)/$(PLATFORM_DIR) #? Clean only Objects From 2b18c6952dad149386b83abe7173ce661a41ea02 Mon Sep 17 00:00:00 2001 From: simplepad <35456194+simplepad@users.noreply.github.com> Date: Wed, 21 Dec 2022 21:43:20 +0300 Subject: [PATCH 082/209] fix zfs on freebsd not reporting IO --- src/freebsd/btop_collect.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/freebsd/btop_collect.cpp b/src/freebsd/btop_collect.cpp index 613e996..2b92ba3 100644 --- a/src/freebsd/btop_collect.cpp +++ b/src/freebsd/btop_collect.cpp @@ -583,8 +583,8 @@ namespace Mem { if (f()) { char buf[512]; size_t len = 512; + uint64_t nread = 0, nwritten = 0; while (not std::feof(f())) { - uint64_t nread = 0, nwritten = 0; if (fgets(buf, len, f())) { char *name = std::strtok(buf, ": \n"); char *value = std::strtok(NULL, ": \n"); From 191b23425e6557654e1e8bf0f7b52b827c40b4fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Bechet?= <48946818+flipflop133@users.noreply.github.com> Date: Sat, 24 Dec 2022 11:22:38 +0100 Subject: [PATCH 083/209] Create adwaita.theme Add the popular Adwaita theme for people who like a theme matching GTK applications. Note: I used a 3 colors gradient while the start and mid-colors are the same, this is not a mistake, it's because using a two colors gradient it would create ugly mid-colors. --- themes/adwaita.theme | 89 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 themes/adwaita.theme diff --git a/themes/adwaita.theme b/themes/adwaita.theme new file mode 100644 index 0000000..25e6bbf --- /dev/null +++ b/themes/adwaita.theme @@ -0,0 +1,89 @@ +#Bashtop Adwaita theme +#by flipflop133 + +# Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" +# example for white: "#FFFFFF", "#ff" or "255 255 255". + +# All graphs and meters can be gradients +# For single color graphs leave "mid" and "end" variable empty. +# Use "start" and "end" variables for two color gradient +# Use "start", "mid" and "end" for three color gradient + +# Main background, empty for terminal default, need to be empty if you want transparent background +theme[main_bg]="#f6f5f4" + +# Main text color +theme[main_fg]="#2e3436" + +# Title color for boxes +theme[title]="#2e3436" + +# Higlight color for keyboard shortcuts +theme[hi_fg]="#1a5fb4" + +# Background color of selected item in processes box +theme[selected_bg]="#1c71d8" + +# Foreground color of selected item in processes box +theme[selected_fg]="#ffffff" + +# Color of inactive/disabled text +theme[inactive_fg]="#5e5c64" + +# Misc colors for processes box including mini cpu graphs, details memory graph and details status text +theme[proc_misc]="#1a5fb4" + +# Cpu box outline color +theme[cpu_box]="#2e3436" + +# Memory/disks box outline color +theme[mem_box]="#3d3c14" + +# Net up/down box outline color +theme[net_box]="#2e3436" + +# Processes box outline color +theme[proc_box]="#2e3436" + +# Box divider line and small boxes line color +theme[div_line]="#2e3436" + +# Temperature graph colors +theme[temp_start]="#1a5fb4" +theme[temp_mid]="#1a5fb4" +theme[temp_end]="#c01c28" + +# CPU graph colors +theme[cpu_start]="#1a5fb4" +theme[cpu_mid]="#1a5fb4" +theme[cpu_end]="#c01c28" + +# Mem/Disk free meter +theme[free_start]="#1a5fb4" +theme[free_mid]="#1a5fb4" +theme[free_end]="#c01c28" + +# Mem/Disk cached meter +theme[cached_start]="#1a5fb4" +theme[cached_mid]="#1a5fb4" +theme[cached_end]="#c01c28" + +# Mem/Disk available meter +theme[available_start]="#1a5fb4" +theme[available_mid]="#1a5fb4" +theme[available_end]="#c01c28" + +# Mem/Disk used meter +theme[used_start]="#1a5fb4" +theme[used_mid]="#1a5fb4" +theme[used_end]="#c01c28" + +# Download graph colors +theme[download_start]="#1a5fb4" +theme[download_mid]="#1a5fb4" +theme[download_end]="#c01c28" + +# Upload graph colors +theme[upload_start]="#1a5fb4" +theme[upload_mid]="#1a5fb4" +theme[upload_end]="#c01c28" From 99c5991c1c8b591694b3fad18e46844fb77f321c Mon Sep 17 00:00:00 2001 From: Steffen Date: Mon, 13 Feb 2023 00:36:10 +0000 Subject: [PATCH 084/209] Replace -ftree-loop-vectorize with -ftree-vectorize. In preparation for LLVM support use -ftree-vectorize as it is understood by clang (unlike -ftree-loop-vectorize) and it is an umbrella for the former and -ftree-slp-vectorize. See https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html. --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c746c00..064397e 100644 --- a/Makefile +++ b/Makefile @@ -130,7 +130,7 @@ override GOODFLAGS := $(foreach flag,$(TESTFLAGS),$(strip $(shell echo "int main #? Flags, Libraries and Includes override REQFLAGS := -std=c++20 WARNFLAGS := -Wall -Wextra -pedantic -OPTFLAGS := -O2 -ftree-loop-vectorize -flto=$(THREADS) +OPTFLAGS := -O2 -ftree-vectorize -flto=$(THREADS) LDCXXFLAGS := -pthread -D_FORTIFY_SOURCE=2 -D_GLIBCXX_ASSERTIONS $(GOODFLAGS) $(ADDFLAGS) override CXXFLAGS += $(REQFLAGS) $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) override LDFLAGS += $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) From 345bf7c0522e53aaaa8b76ca2f9c0296d14b426c Mon Sep 17 00:00:00 2001 From: Matt Ickstadt Date: Thu, 23 Feb 2023 10:59:10 -0600 Subject: [PATCH 085/209] Linux: subtract ZFS ARC min size from available memory --- src/linux/btop_collect.cpp | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 62a5c62..8be5dc7 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -815,7 +815,6 @@ namespace Mem { fs::file_time_type fstab_time; int disk_ios{}; // defaults to 0 vector last_found; - const std::regex zfs_size_regex("^size\\s+\\d\\s+(\\d+)"); //?* Find the filepath to the specified ZFS object's stat file fs::path get_zfs_stat_file(const string& device_name, size_t dataset_name_start, bool zfs_hide_datasets); @@ -851,15 +850,17 @@ namespace Mem { mem.stats.at("swap_total") = 0; //? Read ZFS ARC info from /proc/spl/kstat/zfs/arcstats - uint64_t arc_size = 0; + uint64_t arc_size = 0, arc_min_size = 0; if (zfs_arc_cached) { ifstream arcstats(Shared::procPath / "spl/kstat/zfs/arcstats"); if (arcstats.good()) { - std::string line; - while (std::getline(arcstats, line)) { - std::smatch match; - if (std::regex_match(line, match, zfs_size_regex) && match.size() == 2) { - arc_size = stoull(match.str(1)); + for (string label; arcstats >> label;) { + if (label == "c_min") { + arcstats >> arc_min_size >> arc_min_size; // double read skips type column + } + else if (label == "size") { + arcstats >> arc_size >> arc_size; + break; } } } @@ -899,7 +900,9 @@ namespace Mem { if (not got_avail) mem.stats.at("available") = mem.stats.at("free") + mem.stats.at("cached"); if (zfs_arc_cached) { mem.stats.at("cached") += arc_size; - mem.stats.at("available") += arc_size; + // The ARC will not shrink below arc_min_size, so that memory is not available + if (arc_size > arc_min_size) + mem.stats.at("available") += arc_size - arc_min_size; } mem.stats.at("used") = totalMem - (mem.stats.at("available") <= totalMem ? mem.stats.at("available") : mem.stats.at("free")); From 4d6e79156fadd0da76e18794d94e4501bb03c961 Mon Sep 17 00:00:00 2001 From: Matt Ickstadt Date: Thu, 23 Feb 2023 11:29:22 -0600 Subject: [PATCH 086/209] readme: Add zfs_arc_cached documentation --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 3ad5773..b0377c8 100644 --- a/README.md +++ b/README.md @@ -753,6 +753,9 @@ mem_graphs = True #* Show mem box below net box instead of above. mem_below_net = False +#* Count ZFS ARC in cached and available memory. +zfs_arc_cached = True + #* If swap memory should be shown in memory box. show_swap = True From c9399ab89aefdc3fbe8c16a2effdcfda5cd0b77a Mon Sep 17 00:00:00 2001 From: iambeingtracked <94642304+iambeingtracked@users.noreply.github.com> Date: Wed, 1 Mar 2023 07:42:34 +0000 Subject: [PATCH 087/209] Update everforest-dark-hard.theme Recently Everforest developers [updated](https://github.com/sainnhe/everforest/issues/110) the color scheme. This is an edit that changes the colors in accordance with the new Everforest colors and also changes the net graph colors to have a better-looking gradient. --- themes/everforest-dark-hard.theme | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/themes/everforest-dark-hard.theme b/themes/everforest-dark-hard.theme index 51a5a03..eb8147a 100644 --- a/themes/everforest-dark-hard.theme +++ b/themes/everforest-dark-hard.theme @@ -1,12 +1,10 @@ -# Btop everforest dark hard theme by u/archontop. - # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background -theme[main_bg]="#2b3339" +theme[main_bg]="#272e33" # Main text color theme[main_fg]="#d3c6aa" @@ -18,13 +16,13 @@ theme[title]="#d3c6aa" theme[hi_fg]="#e67e80" # Background color of selected items -theme[selected_bg]="#4b565c" +theme[selected_bg]="#374145" # Foreground color of selected items theme[selected_fg]="#dbbc7f" # Color of inactive/disabled text -theme[inactive_fg]="#2b3339" +theme[inactive_fg]="#272e33" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#d3c6aa" @@ -33,19 +31,19 @@ theme[graph_text]="#d3c6aa" theme[proc_misc]="#a7c080" # Cpu box outline color -theme[cpu_box]="#4b565c" +theme[cpu_box]="#374145" # Memory/disks box outline color -theme[mem_box]="#4b565c" +theme[mem_box]="#374145" # Net up/down box outline color -theme[net_box]="#4b565c" +theme[net_box]="#374145" # Processes box outline color -theme[proc_box]="#4b565c" +theme[proc_box]="#374145" # Box divider line and small boxes line color -theme[div_line]="#4b565c" +theme[div_line]="#374145" # Temperature graph colors theme[temp_start]="#a7c080" @@ -78,14 +76,14 @@ theme[used_mid]="#dbbc7f" theme[used_end]="#f85552" # Download graph colors -theme[download_start]="#8da101" +theme[download_start]="#a7c080" theme[download_mid]="#83c092" -theme[download_end]="#a7c080" +theme[download_end]="#7fbbb3" # Upload graph colors -theme[upload_start]="#f85552" -theme[upload_mid]="#dbbc7f" -theme[upload_end]="#a7c080" +theme[upload_start]="#dbbc7f" +theme[upload_mid]="#e69875" +theme[upload_end]="#e67e80" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#a7c080" From 053bacef1db1a57150c14c8a008ca85442742307 Mon Sep 17 00:00:00 2001 From: Steffen Date: Tue, 7 Mar 2023 13:16:04 +0100 Subject: [PATCH 088/209] Silence "warning: unqualified call to 'std::move'" in clang. --- src/btop_menu.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index cf2fba2..a29a1c7 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -1326,11 +1326,11 @@ namespace Menu { optionsMenu(""); } if (screen_redraw) { - auto overlay_bkp = move(Global::overlay); - auto clock_bkp = move(Global::clock); + auto overlay_bkp = std::move(Global::overlay); + auto clock_bkp = std::move(Global::clock); Draw::calcSizes(); - Global::overlay = move(overlay_bkp); - Global::clock = move(clock_bkp); + Global::overlay = std::move(overlay_bkp); + Global::clock = std::move(clock_bkp); recollect = true; } if (recollect) { From d30c23178ab06be3e5ba657b518c67c8e89ec634 Mon Sep 17 00:00:00 2001 From: Gwenael Ropert Date: Thu, 11 May 2023 16:09:06 +0200 Subject: [PATCH 089/209] Fix link to themes folder --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b0377c8..63505db 100644 --- a/README.md +++ b/README.md @@ -159,7 +159,7 @@ C++ version and continuation of [bashtop](https://github.com/aristocratos/bashto Btop++ uses the same theme files as bpytop and bashtop (some color values missing in bashtop themes) . -See [themes](https://github.com/aristocratos/btop/tree/master/themes) folder for available themes. +See [themes](https://github.com/aristocratos/btop/tree/main/themes) folder for available themes. The `make install` command places the default themes in `[$PREFIX or /usr/local]/share/btop/themes`. User created themes should be placed in `$XDG_CONFIG_HOME/btop/themes` or `$HOME/.config/btop/themes`. From d522a91ef4a95ccd2ff0df45271ff86fc119ab67 Mon Sep 17 00:00:00 2001 From: romner Date: Fri, 12 May 2023 19:34:47 +0200 Subject: [PATCH 090/209] Add rudimentary, fullscreen single-GPU NVML utilization graph --- Makefile | 28 +++++++----- README.md | 2 +- src/btop.cpp | 35 ++++++++++++--- src/btop_config.cpp | 4 +- src/btop_config.hpp | 2 +- src/btop_draw.cpp | 79 ++++++++++++++++++++++++++++++--- src/btop_input.cpp | 4 +- src/btop_menu.cpp | 2 +- src/btop_shared.hpp | 23 ++++++++++ src/linux/btop_collect.cpp | 89 ++++++++++++++++++++++++++++++++++++++ 10 files changed, 238 insertions(+), 30 deletions(-) diff --git a/Makefile b/Makefile index 69100ef..14d2c5c 100644 --- a/Makefile +++ b/Makefile @@ -164,8 +164,10 @@ override REQFLAGS := -std=c++20 WARNFLAGS := -Wall -Wextra -pedantic OPTFLAGS := -O2 -ftree-vectorize -flto=$(LTO) LDCXXFLAGS := -pthread -D_FORTIFY_SOURCE=2 -D_GLIBCXX_ASSERTIONS -D_FILE_OFFSET_BITS=64 $(GOODFLAGS) $(ADDFLAGS) -override CXXFLAGS += $(REQFLAGS) $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) -override LDFLAGS += $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) +GPUCXXFLAGS := -I/opt/cuda/include # TODO: there has to be a better way to link NVML than hardcoded dirs +GPULDFLAGS := -L/usr/lib64 -lnvidia-ml +override CXXFLAGS += $(REQFLAGS) $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) $(GPUCXXFLAGS) +override LDFLAGS += $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) $(GPULDFLAGS) INC := $(foreach incdir,$(INCDIRS),-isystem $(incdir)) -I$(SRCDIR) SU_USER := root @@ -202,16 +204,18 @@ all: $(PRE) directories btop info: @printf " $(BANNER)\n" - @printf "\033[1;92mPLATFORM \033[1;93m?| \033[0m$(PLATFORM)\n" - @printf "\033[1;96mARCH \033[1;93m?| \033[0m$(ARCH)\n" - @printf "\033[1;93mCXX \033[1;93m?| \033[0m$(CXX) \033[1;93m(\033[97m$(CXX_VERSION)\033[93m)\n" - @printf "\033[1;94mTHREADS \033[1;94m:| \033[0m$(THREADS)\n" - @printf "\033[1;92mREQFLAGS \033[1;91m!| \033[0m$(REQFLAGS)\n" - @printf "\033[1;91mWARNFLAGS \033[1;94m:| \033[0m$(WARNFLAGS)\n" - @printf "\033[1;94mOPTFLAGS \033[1;94m:| \033[0m$(OPTFLAGS)\n" - @printf "\033[1;93mLDCXXFLAGS \033[1;94m:| \033[0m$(LDCXXFLAGS)\n" - @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDCXX)\n" - @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDLD)\n" + @printf "\033[1;92mPLATFORM \033[1;93m?| \033[0m$(PLATFORM)\n" + @printf "\033[1;96mARCH \033[1;93m?| \033[0m$(ARCH)\n" + @printf "\033[1;93mCXX \033[1;93m?| \033[0m$(CXX) \033[1;93m(\033[97m$(CXX_VERSION)\033[93m)\n" + @printf "\033[1;94mTHREADS \033[1;94m:| \033[0m$(THREADS)\n" + @printf "\033[1;92mREQFLAGS \033[1;91m!| \033[0m$(REQFLAGS)\n" + @printf "\033[1;91mWARNFLAGS \033[1;94m:| \033[0m$(WARNFLAGS)\n" + @printf "\033[1;94mOPTFLAGS \033[1;94m:| \033[0m$(OPTFLAGS)\n" + @printf "\033[1;93mLDCXXFLAGS \033[1;94m:| \033[0m$(LDCXXFLAGS)\n" + @printf "\033[1;92mGPUCXXFLAGS \033[1;94m:| \033[0m$(GPUCXXFLAGS)\n" + @printf "\033[1;92mGPULDFLAGS \033[1;94m:| \033[0m$(GPULDFLAGS)\n" + @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDCXX)\n" + @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDLD)\n" info-quiet: @sleep 0.1 2>/dev/null || true diff --git a/README.md b/README.md index 5966dc2..5c56eea 100644 --- a/README.md +++ b/README.md @@ -655,7 +655,7 @@ graph_symbol_net = "default" # Graph symbol to use for graphs in cpu box, "default", "braille", "block" or "tty". graph_symbol_proc = "default" -#* Manually set which boxes to show. Available values are "cpu mem net proc", separate values with whitespace. +#* Manually set which boxes to show. Available values are "cpu mem net proc gpu", separate values with whitespace. shown_boxes = "proc cpu mem net" #* Update time in milliseconds, recommended 2000 ms or above for better sample times for graphs. diff --git a/src/btop.cpp b/src/btop.cpp index 552adae..f97e448 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -187,7 +187,7 @@ void term_resize(bool force) { } else return; - static const array all_boxes = {"cpu", "mem", "net", "proc"}; + static const array all_boxes = {"cpu", "mem", "net", "proc", "gpu"}; Global::resized = true; if (Runner::active) Runner::stop(); Term::refresh(); @@ -583,6 +583,27 @@ namespace Runner { throw std::runtime_error("Proc:: -> " + string{e.what()}); } } + + //? GPU + if (v_contains(conf.boxes, "gpu")) { + try { + if (Global::debug) debug_timer("gpu", collect_begin); + + //? Start collect + auto gpu = Gpu::collect(conf.no_update); + + if (Global::debug) debug_timer("gpu", draw_begin); + + //? Draw box + if (not pause_output) output += Gpu::draw(gpu, conf.force_redraw, conf.no_update); + + if (Global::debug) debug_timer("gpu", draw_done); + } + catch (const std::exception& e) { + throw std::runtime_error("Gpu:: -> " + string{e.what()}); + } + } + } catch (const std::exception& e) { Global::exit_error_msg = "Exception in runner thread -> " + string{e.what()}; @@ -613,8 +634,9 @@ namespace Runner { "{mv3}{hiFg}2 {mainFg}| Show MEM box" "{mv4}{hiFg}3 {mainFg}| Show NET box" "{mv5}{hiFg}4 {mainFg}| Show PROC box" - "{mv6}{hiFg}esc {mainFg}| Show menu" - "{mv7}{hiFg}q {mainFg}| Quit", + "{mv6}{hiFg}5 {mainFg}| Show GPU box" + "{mv7}{hiFg}esc {mainFg}| Show menu" + "{mv8}{hiFg}q {mainFg}| Quit", "banner"_a = Draw::banner_gen(y, 0, true), "titleFg"_a = Theme::c("title"), "b"_a = Fx::b, "hiFg"_a = Theme::c("hi_fg"), "mainFg"_a = Theme::c("main_fg"), "mv1"_a = Mv::to(y+6, x), @@ -622,8 +644,9 @@ namespace Runner { "mv3"_a = Mv::to(y+9, x), "mv4"_a = Mv::to(y+10, x), "mv5"_a = Mv::to(y+11, x), - "mv6"_a = Mv::to(y+12, x-2), - "mv7"_a = Mv::to(y+13, x) + "mv6"_a = Mv::to(y+12, x), + "mv7"_a = Mv::to(y+13, x-2), + "mv8"_a = Mv::to(y+14, x) ); } output += empty_bg; @@ -637,7 +660,7 @@ namespace Runner { "post"_a = Theme::c("main_fg") + Fx::ub ); static auto loc = std::locale(std::locale::classic(), new MyNumPunct); - for (const string name : {"cpu", "mem", "net", "proc", "total"}) { + for (const string name : {"cpu", "mem", "net", "proc", "gpu", "total"}) { if (not debug_times.contains(name)) debug_times[name] = {0,0}; const auto& [time_collect, time_draw] = debug_times.at(name); if (name == "total") output += Fx::b; diff --git a/src/btop_config.cpp b/src/btop_config.cpp index b4bdec2..495af23 100644 --- a/src/btop_config.cpp +++ b/src/btop_config.cpp @@ -78,7 +78,7 @@ namespace Config { {"graph_symbol_proc", "# Graph symbol to use for graphs in cpu box, \"default\", \"braille\", \"block\" or \"tty\"."}, - {"shown_boxes", "#* Manually set which boxes to show. Available values are \"cpu mem net proc\", separate values with whitespace."}, + {"shown_boxes", "#* Manually set which boxes to show. Available values are \"cpu mem net proc gpu\", separate values with whitespace."}, {"update_ms", "#* Update time in milliseconds, recommended 2000 ms or above for better sample times for graphs."}, @@ -316,7 +316,7 @@ namespace Config { validError = "Malformatted preset in config value presets!"; return false; } - if (not is_in(vals.at(0), "cpu", "mem", "net", "proc")) { + if (not is_in(vals.at(0), "cpu", "mem", "net", "proc", "gpu")) { validError = "Invalid box name in config value presets!"; return false; } diff --git a/src/btop_config.hpp b/src/btop_config.hpp index bbebc9b..46e6a4c 100644 --- a/src/btop_config.hpp +++ b/src/btop_config.hpp @@ -42,7 +42,7 @@ namespace Config { const vector valid_graph_symbols = { "braille", "block", "tty" }; const vector valid_graph_symbols_def = { "default", "braille", "block", "tty" }; - const vector valid_boxes = { "cpu", "mem", "net", "proc" }; + const vector valid_boxes = { "cpu", "mem", "net", "proc", "gpu" }; const vector temp_scales = { "celsius", "fahrenheit", "kelvin", "rankine" }; extern vector current_boxes; diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 2352b09..5fb10d0 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -28,6 +28,7 @@ tab-size = 4 #include #include #include +#include using std::array; using std::clamp; @@ -1575,6 +1576,62 @@ namespace Proc { } +namespace Gpu { + int width_p = 100, height_p = 32; + int min_width = 60, min_height = 8; + int x = 1, y = 1, width = 20, height; + int b_columns, b_column_size; + int b_x, b_y, b_width, b_height; + bool shown = true, redraw = true, mid_line = false; + int graph_height; + Draw::Graph graph_upper; + string box; + + string draw(const gpu_info& gpu, bool force_redraw, bool data_same) { + if (Runner::stopping) return ""; + if (force_redraw) redraw = true; + auto tty_mode = Config::getB("tty_mode"); + auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_cpu")); // TODO graph_symbol_gpu + auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); + string out; + out.reserve(width * height); + + //* Redraw elements not needed to be updated every cycle + if (redraw) { + out += box; + graph_height = height-2; + //out += Gpu::Nvml::initialized ? "NVML initialized" : "NVML not initialized"; + graph_upper = Draw::Graph{x + width - b_width - 3, graph_height, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu + } + //out += " " + std::to_string(gpu.gpu_percent.back()) + "%"; + + try { + //? Gpu graphs + out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); + //if (not single_graph) + // out += Mv::to( y + graph_up_height + 1 + (mid_line ? 1 : 0), x + 1) + graph_lower(cpu.cpu_percent.at(graph_lo_field), (data_same or redraw)); + + /*out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "CPU " + cpu_meter(cpu.cpu_percent.at("total").back()) + + Theme::g("cpu").at(clamp(cpu.cpu_percent.at("total").back(), 0ll, 100ll)) + rjust(to_string(cpu.cpu_percent.at("total").back()), 4) + Theme::c("main_fg") + '%'; + if (show_temps) { + const auto [temp, unit] = celsius_to(cpu.temp.at(0).back(), temp_scale); + const auto& temp_color = Theme::g("temp").at(clamp(cpu.temp.at(0).back() * 100 / cpu.temp_max, 0ll, 100ll)); + if (b_column_size > 1 or b_columns > 1) + out += ' ' + Theme::c("inactive_fg") + graph_bg * 5 + Mv::l(5) + temp_color + + temp_graphs.at(0)(cpu.temp.at(0), data_same or redraw); + out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; + }*/ + out += Theme::c("div_line") + Symbols::v_line; + + } catch (const std::exception& e) { + throw std::runtime_error("graphs: " + string{e.what()}); + } + + redraw = false; + return out + Fx::reset; + } +} + namespace Draw { void calcSizes() { atomic_wait(Runner::active); @@ -1588,6 +1645,7 @@ namespace Draw { Mem::box.clear(); Net::box.clear(); Proc::box.clear(); + Gpu::box.clear(); Global::clock.clear(); Global::overlay.clear(); Runner::pause_output = false; @@ -1598,16 +1656,17 @@ namespace Draw { Input::mouse_mappings.clear(); - Cpu::x = Mem::x = Net::x = Proc::x = 1; - Cpu::y = Mem::y = Net::y = Proc::y = 1; - Cpu::width = Mem::width = Net::width = Proc::width = 0; - Cpu::height = Mem::height = Net::height = Proc::height = 0; - Cpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; + Cpu::x = Mem::x = Net::x = Proc::y = Gpu::x = 1; + Cpu::y = Mem::y = Net::y = Proc::y = Gpu::y = 1; + Cpu::width = Mem::width = Net::width = Proc::width = Gpu::width = 0; + Cpu::height = Mem::height = Net::height = Proc::height = Gpu::height = 0; + Cpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = Gpu::redraw = true; Cpu::shown = s_contains(boxes, "cpu"); Mem::shown = s_contains(boxes, "mem"); Net::shown = s_contains(boxes, "net"); Proc::shown = s_contains(boxes, "proc"); + Gpu::shown = s_contains(boxes, "gpu"); //* Calculate and draw cpu box outlines if (Cpu::shown) { @@ -1739,5 +1798,15 @@ namespace Draw { select_max = height - 3; box = createBox(x, y, width, height, Theme::c("proc_box"), true, "proc", "", 4); } + + //* Calculate and draw gpu box outlines + if (Gpu::shown) { + using namespace Gpu; + width = Term::width; + height = Term::height; + x = 1; + y = 1; + box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box + } } } diff --git a/src/btop_input.cpp b/src/btop_input.cpp index 3a09152..9113a42 100644 --- a/src/btop_input.cpp +++ b/src/btop_input.cpp @@ -260,10 +260,10 @@ namespace Input { Menu::show(Menu::Menus::Options); return; } - else if (is_in(key, "1", "2", "3", "4")) { + else if (is_in(key, "1", "2", "3", "4", "5")) { atomic_wait(Runner::active); Config::current_preset = -1; - static const array boxes = {"cpu", "mem", "net", "proc"}; + static const array boxes = {"cpu", "mem", "net", "proc", "gpu"}; Config::toggle_box(boxes.at(std::stoi(key) - 1)); Draw::calcSizes(); Runner::run("all", false, true); diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index a29a1c7..07ecf0a 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -1263,7 +1263,7 @@ namespace Menu { //? Category buttons out += Mv::to(y+7, x+4); - for (int i = 0; const auto& m : {"general", "cpu", "mem", "net", "proc"}) { + for (int i = 0; const auto& m : {"general", "cpu", "mem", "net", "proc", "gpu"}) { out += Fx::b + (i == selected_cat ? Theme::c("hi_fg") + '[' + Theme::c("title") + m + Theme::c("hi_fg") + ']' : Theme::c("hi_fg") + to_string(i + 1) + Theme::c("title") + m + ' ') diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 51d8f3d..8c26c71 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -313,3 +313,26 @@ namespace Proc { int cur_depth, bool collapsed, const string& filter, bool found = false, bool no_update = false, bool should_filter = false); } + +namespace Gpu { + extern string box; + extern int x, y, width, height, min_width, min_height; + extern bool shown, redraw; + + struct gpu_info { + deque gpu_percent = {}; + //deque temp; + //long long temp_max = 0; + //array load_avg; + }; + + namespace Nvml { + extern bool initialized; + } + + //* Collect gpu stats and temperatures + auto collect(bool no_update = false) -> gpu_info&; + + //* Draw contents of gpu box using as source + string draw(const gpu_info& gpu, bool force_redraw, bool data_same); +} diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 2156115..521dd48 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -28,6 +28,7 @@ tab-size = 4 #include #include #include // for inet_ntop() +#include #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) @@ -93,6 +94,19 @@ namespace Mem { double old_uptime; } +namespace Gpu { + gpu_info current_gpu; + unsigned int device_count; + nvmlDevice_t device; + + //? NVIDIA data collection + namespace Nvml { + bool initialized = false; + bool init(); + bool shutdown(); + } +} + namespace Shared { fs::path procPath, passwd_path; @@ -152,6 +166,9 @@ namespace Shared { Mem::old_uptime = system_uptime(); Mem::collect(); + //? Init for namespace Gpu + Gpu::Nvml::init(); + } } @@ -2073,3 +2090,75 @@ namespace Tools { throw std::runtime_error("Failed get uptime from from " + string{Shared::procPath} + "/uptime"); } } + +namespace Gpu { + //? NVIDIA + namespace Nvml { + bool init() { + if (initialized) {return false;} + + nvmlReturn_t result = nvmlInit(); + if (result != NVML_SUCCESS) { + Logger::warning(std::string("Failed to initialize NVML, NVIDIA GPUs will not be detected: ") + nvmlErrorString(result)); + return false; + } + + result = nvmlDeviceGetCount(&device_count); + if (result != NVML_SUCCESS) { + Logger::error(std::string("Failed to get NVML device count: ") + nvmlErrorString(result)); + return false; + } + + result = nvmlDeviceGetHandleByIndex(0, &device); // TODO: multi-GPU support + if (result != NVML_SUCCESS) { + Logger::error(std::string("Failed to get NVML device handle: ") + nvmlErrorString(result)); + return false; + } + + initialized = true; + return true; + } + bool shutdown() { + if (!initialized) {return false;} + + nvmlReturn_t result = nvmlShutdown(); + if (NVML_SUCCESS == result) { + initialized = true; + } else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); + return !initialized; + } + } + // TODO: AMD + // TODO: Intel + + //? Collect data from GPU-specific libraries + auto collect(bool no_update) -> gpu_info& { + if (Runner::stopping or (no_update and not current_gpu.gpu_percent.empty())) return current_gpu; + auto& gpu = current_gpu; + + //if (Config::getB("show_gpu_freq")) + // TODO gpuHz = get_gpuHz(); + + //? Get GPU utilization + if (Nvml::initialized) { + nvmlUtilization_t utilization; + nvmlReturn_t result = nvmlDeviceGetUtilizationRates(device, &utilization); + if (result != NVML_SUCCESS) { + throw std::runtime_error(std::string("Failed to get GPU utilization: ") + nvmlErrorString(result)); + } + + //? Total usage of gpu + gpu.gpu_percent.push_back((long long)utilization.gpu); + + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); + } + + /*if (Config::getB("check_temp")) { + + } + */ + + return gpu; + } +} From adcdc583b098156abc639a068238ef277f166153 Mon Sep 17 00:00:00 2001 From: romner Date: Sat, 13 May 2023 00:27:23 +0200 Subject: [PATCH 091/209] Add GPU side panel --- src/btop.cpp | 2 + src/btop_draw.cpp | 75 ++++++++++++++++++++++++-------- src/btop_menu.cpp | 1 + src/btop_shared.hpp | 11 +++-- src/linux/btop_collect.cpp | 88 +++++++++++++++++++++++++++----------- 5 files changed, 131 insertions(+), 46 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index f97e448..dd189ea 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -261,6 +261,8 @@ void clean_quit(int sig) { #endif } + Gpu::Nvml::shutdown(); + Config::write(); if (Term::initialized) { diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 5fb10d0..ff7ccee 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1585,12 +1585,18 @@ namespace Gpu { bool shown = true, redraw = true, mid_line = false; int graph_height; Draw::Graph graph_upper; + Draw::Graph temp_graph; + Draw::Meter gpu_meter; + Draw::Meter mem_meter; + unordered_flat_map mem_graphs; string box; string draw(const gpu_info& gpu, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; + bool show_temps = (Config::getB("check_temp")); auto tty_mode = Config::getB("tty_mode"); + auto& temp_scale = Config::getS("temp_scale"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_cpu")); // TODO graph_symbol_gpu auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); string out; @@ -1599,29 +1605,53 @@ namespace Gpu { //* Redraw elements not needed to be updated every cycle if (redraw) { out += box; - graph_height = height-2; - //out += Gpu::Nvml::initialized ? "NVML initialized" : "NVML not initialized"; - graph_upper = Draw::Graph{x + width - b_width - 3, graph_height, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu + + graph_upper = Draw::Graph{x + width - b_width - 3, height-2, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu + gpu_meter = Draw::Meter{b_width - (show_temps ? 27 : 11), "cpu"}; + temp_graph = Draw::Graph{9, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23}; + + mem_meter = Draw::Meter{b_width - 27, "used"}; + for (const auto& name : mem_names) { + mem_graphs[name] = Draw::Graph{b_width/2 - (name == "used" ? 1 : 2), 3, name, gpu.mem_percent.at(name), graph_symbol}; + } } //out += " " + std::to_string(gpu.gpu_percent.back()) + "%"; + //? Core text and graphs try { - //? Gpu graphs - out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); - //if (not single_graph) - // out += Mv::to( y + graph_up_height + 1 + (mid_line ? 1 : 0), x + 1) + graph_lower(cpu.cpu_percent.at(graph_lo_field), (data_same or redraw)); + //? Gpu graph & meter + out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); + out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "GPU " + gpu_meter(gpu.gpu_percent.back()) + + Theme::g("cpu").at(gpu.gpu_percent.back()) + rjust(to_string(gpu.gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; - /*out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "CPU " + cpu_meter(cpu.cpu_percent.at("total").back()) - + Theme::g("cpu").at(clamp(cpu.cpu_percent.at("total").back(), 0ll, 100ll)) + rjust(to_string(cpu.cpu_percent.at("total").back()), 4) + Theme::c("main_fg") + '%'; - if (show_temps) { - const auto [temp, unit] = celsius_to(cpu.temp.at(0).back(), temp_scale); - const auto& temp_color = Theme::g("temp").at(clamp(cpu.temp.at(0).back() * 100 / cpu.temp_max, 0ll, 100ll)); - if (b_column_size > 1 or b_columns > 1) + //? Temperature graph + if (show_temps) { + const auto [temp, unit] = celsius_to(gpu.temp.back(), temp_scale); + const auto& temp_color = Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)); out += ' ' + Theme::c("inactive_fg") + graph_bg * 5 + Mv::l(5) + temp_color - + temp_graphs.at(0)(cpu.temp.at(0), data_same or redraw); - out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; - }*/ - out += Theme::c("div_line") + Symbols::v_line; + + temp_graph(gpu.temp, data_same or redraw); + out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; + } + out += Theme::c("div_line") + Symbols::v_line; + + //? Memory usage meter + out += Mv::to(b_y + 2, b_x + 1) + Theme::c("main_fg") + Fx::b + "MEM " + mem_meter(gpu.mem_percent.at("used").back()) + + Theme::g("used").at(gpu.mem_percent.at("used").back()) + rjust(to_string(gpu.mem_percent.at("used").back()), 4) + Theme::c("main_fg") + '%' + + Fx::b + " Total:" + rjust(floating_humanizer(gpu.mem_total), 9); + + //? Memory usage graphs + out += Mv::to(b_y + 4, b_x + 1); + for (const auto& name : mem_names) { + out += mem_graphs[name](gpu.mem_percent.at(name), (data_same or redraw)) + Mv::u(2) + Mv::r(1); + } + + //? Memory usage borders // TODO, there's gotta be a more elegant way to do this... + out += Mv::to(b_y + 3, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "Used:" + Theme::c("div_line") + + Symbols::h_line*(b_width/2-15) + Theme::c("title") + floating_humanizer(gpu.mem_stats.at("used")) + Theme::c("div_line") + Symbols::h_line; + out += Symbols::div_up + Symbols::h_line + Theme::c("title") + "Free:" + Theme::c("div_line") + + Symbols::h_line*(b_width/2-17) + Theme::c("title") + floating_humanizer(gpu.mem_stats.at("free")) + Theme::c("div_line") + Symbols::h_line + Symbols::div_right; + out += Mv::to(b_y + 7, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line*(b_width/2-1) + (Mv::u(1) + Symbols::v_line + Mv::l(1))*3 + + Mv::d(3) + Symbols::div_down + Symbols::h_line*(b_width/2-2) + Symbols::div_right; } catch (const std::exception& e) { throw std::runtime_error("graphs: " + string{e.what()}); @@ -1804,9 +1834,16 @@ namespace Draw { using namespace Gpu; width = Term::width; height = Term::height; - x = 1; - y = 1; + x = 1; y = 1; box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box + + b_width = width/2; // TODO + b_height = height-2; + + b_x = x + width - b_width - 1; + b_y = y + ceil((double)(height - 2) / 2) - ceil((double)b_height / 2) + 1; + + box += createBox(b_x, b_y, b_width, b_height, "", false, "test"); } } } diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index 07ecf0a..fa0028b 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -119,6 +119,7 @@ namespace Menu { {"2", "Toggle MEM box."}, {"3", "Toggle NET box."}, {"4", "Toggle PROC box."}, + {"5", "Toggle GPU box."}, {"d", "Toggle disks view in MEM box."}, {"F2, o", "Shows options."}, {"F1, ?, h", "Shows this window."}, diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 8c26c71..e392ff9 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -319,15 +319,20 @@ namespace Gpu { extern int x, y, width, height, min_width, min_height; extern bool shown, redraw; + const array mem_names { "used"s, "free"s }; + struct gpu_info { deque gpu_percent = {}; - //deque temp; - //long long temp_max = 0; - //array load_avg; + deque temp; + long long temp_max = 0; + unordered_flat_map mem_stats = {{"used", 0}, {"free", 0}}; + unordered_flat_map> mem_percent = {{"used", {}}, {"free", {}}}; + long long mem_total = 0; }; namespace Nvml { extern bool initialized; + extern bool shutdown(); } //* Collect gpu stats and temperatures diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 521dd48..5a4d4c4 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -97,13 +97,13 @@ namespace Mem { namespace Gpu { gpu_info current_gpu; unsigned int device_count; - nvmlDevice_t device; //? NVIDIA data collection namespace Nvml { bool initialized = false; bool init(); bool shutdown(); + nvmlDevice_t device; } } @@ -2087,7 +2087,7 @@ namespace Tools { catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} } - throw std::runtime_error("Failed get uptime from from " + string{Shared::procPath} + "/uptime"); + throw std::runtime_error("Failed get uptime from " + string{Shared::procPath} + "/uptime"); } } @@ -2105,17 +2105,26 @@ namespace Gpu { result = nvmlDeviceGetCount(&device_count); if (result != NVML_SUCCESS) { - Logger::error(std::string("Failed to get NVML device count: ") + nvmlErrorString(result)); + Logger::error(std::string("NVML: Failed to get device count: ") + nvmlErrorString(result)); return false; } result = nvmlDeviceGetHandleByIndex(0, &device); // TODO: multi-GPU support if (result != NVML_SUCCESS) { - Logger::error(std::string("Failed to get NVML device handle: ") + nvmlErrorString(result)); + Logger::error(std::string("NVML: Failed to get device handle: ") + nvmlErrorString(result)); return false; } initialized = true; + + //? Get temp_max + unsigned int temp_max; + result = nvmlDeviceGetTemperatureThreshold(device, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN, &temp_max); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get maximum GPU temperature: ") + nvmlErrorString(result)); + return false; + } + current_gpu.temp_max = (long long)temp_max; return true; } bool shutdown() { @@ -2127,10 +2136,59 @@ namespace Gpu { } else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); return !initialized; } + bool collect(gpu_info& gpu) { + if (!initialized) return false; + + //? Get GPU utilization + nvmlUtilization_t utilization; + nvmlReturn_t result = nvmlDeviceGetUtilizationRates(device, &utilization); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU utilization: ") + nvmlErrorString(result)); + return false; + } + gpu.gpu_percent.push_back((long long)utilization.gpu); + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); + + //? GPU temp + if (Config::getB("check_temp")) { + unsigned int temp; + nvmlReturn_t result = nvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &temp); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU temperature: ") + nvmlErrorString(result)); + return false; + } + gpu.temp.push_back((long long)temp); + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); + } + + //? Memory info + nvmlMemory_t memory; + result = nvmlDeviceGetMemoryInfo(device, &memory); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get VRAM info: ") + nvmlErrorString(result)); + return false; + } + + gpu.mem_total = memory.total; + gpu.mem_stats.at("used") = memory.used; + gpu.mem_stats.at("free") = memory.free; + + auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); + gpu.mem_percent.at("used").push_back(used_percent); + gpu.mem_percent.at("free").push_back(100-used_percent); + + //? Reduce size if there are more values than needed for graphs + while (cmp_greater(gpu.mem_percent.at("used").size(), width/2)) gpu.mem_percent.at("used").pop_front(); + while (cmp_greater(gpu.mem_percent.at("free").size(), width/2)) gpu.mem_percent.at("free").pop_front(); + + return true; + } } // TODO: AMD // TODO: Intel - + //? Collect data from GPU-specific libraries auto collect(bool no_update) -> gpu_info& { if (Runner::stopping or (no_update and not current_gpu.gpu_percent.empty())) return current_gpu; @@ -2139,25 +2197,7 @@ namespace Gpu { //if (Config::getB("show_gpu_freq")) // TODO gpuHz = get_gpuHz(); - //? Get GPU utilization - if (Nvml::initialized) { - nvmlUtilization_t utilization; - nvmlReturn_t result = nvmlDeviceGetUtilizationRates(device, &utilization); - if (result != NVML_SUCCESS) { - throw std::runtime_error(std::string("Failed to get GPU utilization: ") + nvmlErrorString(result)); - } - - //? Total usage of gpu - gpu.gpu_percent.push_back((long long)utilization.gpu); - - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); - } - - /*if (Config::getB("check_temp")) { - - } - */ + Nvml::collect(gpu); return gpu; } From 95b32283083ca2b74824a94ce97561b323ea1d17 Mon Sep 17 00:00:00 2001 From: romner Date: Sat, 13 May 2023 19:41:51 +0200 Subject: [PATCH 092/209] Improve GPU side panel --- src/btop_draw.cpp | 81 ++++++++++++++++---------- src/btop_shared.hpp | 23 ++++++-- src/linux/btop_collect.cpp | 113 +++++++++++++++++++++++++++---------- 3 files changed, 155 insertions(+), 62 deletions(-) diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index ff7ccee..1137fa1 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1586,9 +1586,10 @@ namespace Gpu { int graph_height; Draw::Graph graph_upper; Draw::Graph temp_graph; + Draw::Graph mem_used_graph; + Draw::Graph mem_util_graph; Draw::Meter gpu_meter; - Draw::Meter mem_meter; - unordered_flat_map mem_graphs; + Draw::Meter pwr_meter; string box; string draw(const gpu_info& gpu, bool force_redraw, bool data_same) { @@ -1607,51 +1608,73 @@ namespace Gpu { out += box; graph_upper = Draw::Graph{x + width - b_width - 3, height-2, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu - gpu_meter = Draw::Meter{b_width - (show_temps ? 27 : 11), "cpu"}; - temp_graph = Draw::Graph{9, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23}; + gpu_meter = Draw::Meter{b_width - (show_temps ? 24 : 11), "cpu"}; + temp_graph = Draw::Graph{6, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23}; - mem_meter = Draw::Meter{b_width - 27, "used"}; - for (const auto& name : mem_names) { - mem_graphs[name] = Draw::Graph{b_width/2 - (name == "used" ? 1 : 2), 3, name, gpu.mem_percent.at(name), graph_symbol}; - } + pwr_meter = Draw::Meter{b_width - 24, "cached"}; + + mem_util_graph = Draw::Graph{b_width/2 - 1, 2, "free", gpu.mem_utilization_percent, graph_symbol, 0, 0, 100, 4}; // offset so the graph isn't empty at 0-5% I/O + mem_used_graph = Draw::Graph{b_width/2 - 2, 4, "used", gpu.mem_used_percent, graph_symbol}; } - //out += " " + std::to_string(gpu.gpu_percent.back()) + "%"; //? Core text and graphs try { - //? Gpu graph & meter + //? Gpu graph, clock speed & meter out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); + + if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq + string clock_speed_string = to_string(gpu.gpu_clock_speed); + out += Mv::to(b_y, b_x + b_width - 12) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) + + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " Mhz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; + } + out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "GPU " + gpu_meter(gpu.gpu_percent.back()) + Theme::g("cpu").at(gpu.gpu_percent.back()) + rjust(to_string(gpu.gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; //? Temperature graph if (show_temps) { const auto [temp, unit] = celsius_to(gpu.temp.back(), temp_scale); - const auto& temp_color = Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)); - out += ' ' + Theme::c("inactive_fg") + graph_bg * 5 + Mv::l(5) + temp_color + out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)) + temp_graph(gpu.temp, data_same or redraw); out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; } out += Theme::c("div_line") + Symbols::v_line; - //? Memory usage meter - out += Mv::to(b_y + 2, b_x + 1) + Theme::c("main_fg") + Fx::b + "MEM " + mem_meter(gpu.mem_percent.at("used").back()) - + Theme::g("used").at(gpu.mem_percent.at("used").back()) + rjust(to_string(gpu.mem_percent.at("used").back()), 4) + Theme::c("main_fg") + '%' - + Fx::b + " Total:" + rjust(floating_humanizer(gpu.mem_total), 9); + //? Power usage meter, power state + out += Mv::to(b_y + 2, b_x + 1) + Theme::c("main_fg") + Fx::b + "PWR " + pwr_meter(gpu.pwr_percent.back()) + + Theme::g("cached").at(gpu.pwr_percent.back()) + rjust(to_string(gpu.pwr_usage/1000), 4) + Theme::c("main_fg") + 'W' + + " P-state: " + (gpu.pwr_state > 9 ? "" : " ") + 'P' + Theme::g("cached").at(gpu.pwr_state) + to_string(gpu.pwr_state); - //? Memory usage graphs - out += Mv::to(b_y + 4, b_x + 1); - for (const auto& name : mem_names) { - out += mem_graphs[name](gpu.mem_percent.at(name), (data_same or redraw)) + Mv::u(2) + Mv::r(1); + //? Memory section header & clock speed + string used_memory_string = floating_humanizer(gpu.mem_used); + out += Mv::to(b_y + 3, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Fx::b + Theme::c("title") + "vram" + + Theme::c("div_line") + Fx::ub + Symbols::title_right + Symbols::h_line*(b_width/2-8) + Symbols::div_up + Symbols::h_line + + Theme::c("title") + "Used:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-9-used_memory_string.size()) + Theme::c("title") + used_memory_string + Theme::c("div_line") + Symbols::h_line + Symbols::div_right; + if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq + string clock_speed_string = to_string(gpu.mem_clock_speed); + out += Mv::to(b_y + 3, b_x + b_width/2 - 11) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) + + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " Mhz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; } - //? Memory usage borders // TODO, there's gotta be a more elegant way to do this... - out += Mv::to(b_y + 3, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "Used:" + Theme::c("div_line") - + Symbols::h_line*(b_width/2-15) + Theme::c("title") + floating_humanizer(gpu.mem_stats.at("used")) + Theme::c("div_line") + Symbols::h_line; - out += Symbols::div_up + Symbols::h_line + Theme::c("title") + "Free:" + Theme::c("div_line") - + Symbols::h_line*(b_width/2-17) + Theme::c("title") + floating_humanizer(gpu.mem_stats.at("free")) + Theme::c("div_line") + Symbols::h_line + Symbols::div_right; - out += Mv::to(b_y + 7, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line*(b_width/2-1) + (Mv::u(1) + Symbols::v_line + Mv::l(1))*3 - + Mv::d(3) + Symbols::div_down + Symbols::h_line*(b_width/2-2) + Symbols::div_right; + //? Memory usage borders + out += Mv::to(b_y + 5, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "I/O:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-6) + + Symbols::div_right + Mv::u(1)+Mv::l(1) + Symbols::v_line + Mv::l(1)+Mv::d(2) + (Symbols::v_line + Mv::l(1)+Mv::d(1))*2; + + //? Total memory usage + out += Mv::to(b_y + 4, b_x + 2) + Theme::c("main_fg") + Fx::b + "Total:" + rjust(floating_humanizer(gpu.mem_total), b_width/2-9) + Fx::ub; + + //? Memory usage graphs & percentage + out += Mv::to(b_y+6, b_x+1) + Theme::c("inactive_fg") + mem_util_graph(gpu.mem_utilization_percent, (data_same or redraw)) + + Mv::u(3) + Mv::r(1) + mem_used_graph(gpu.mem_used_percent, (data_same or redraw)); + out += Mv::to(b_y+6, b_x+1) + rjust(to_string(gpu.mem_utilization_percent.back()), 3) + '%' + Mv::u(2) + Mv::r(b_width/2-3) + rjust(to_string(gpu.mem_used_percent.back()), 3) + '%'; + + //? Processes section header + out += Mv::to(b_y+8, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Theme::c("main_fg") + Fx::b + "gpu-proc" + Fx::ub + Theme::c("div_line") + + Symbols::title_right + Symbols::h_line*(b_width/2-12) + Symbols::div_down + Symbols::h_line*(b_width/2-2) + Symbols::div_right; + + //? PCIe link throughput + out += Mv::to(b_y + b_height - 1, b_x+2) + Symbols::title_left_down + Theme::c("main_fg") + "TX: " + floating_humanizer(gpu.pcie_tx, 0, 1, 0, 1) + Theme::c("div_line") + + Symbols::title_right_down + Symbols::title_left_down + Theme::c("main_fg") + "RX: " + floating_humanizer(gpu.pcie_rx, 0, 1, 0, 1) + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*10; } catch (const std::exception& e) { throw std::runtime_error("graphs: " + string{e.what()}); @@ -1837,13 +1860,13 @@ namespace Draw { x = 1; y = 1; box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box - b_width = width/2; // TODO + b_width = width/2 - width%2; // TODO b_height = height-2; b_x = x + width - b_width - 1; b_y = y + ceil((double)(height - 2) / 2) - ceil((double)b_height / 2) + 1; - box += createBox(b_x, b_y, b_width, b_height, "", false, "test"); + box += createBox(b_x, b_y, b_width, b_height, "", false, gpu_name); } } } diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index e392ff9..5c121be 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -318,16 +318,31 @@ namespace Gpu { extern string box; extern int x, y, width, height, min_width, min_height; extern bool shown, redraw; + extern string gpu_name; const array mem_names { "used"s, "free"s }; struct gpu_info { deque gpu_percent = {}; - deque temp; - long long temp_max = 0; - unordered_flat_map mem_stats = {{"used", 0}, {"free", 0}}; - unordered_flat_map> mem_percent = {{"used", {}}, {"free", {}}}; + unsigned int gpu_clock_speed = 0; // MHz + + deque pwr_percent = {}; + unsigned int pwr_usage = 0; // mW + unsigned int pwr_max_usage = 300000; + unsigned int pwr_state = 32; + + deque temp = {}; + long long temp_max = 100; + long long mem_total = 0; + long long mem_used = 0; + deque mem_used_percent = {}; + long long mem_utilization = 0; + deque mem_utilization_percent = {}; + unsigned int mem_clock_speed = 0; // MHz + + unsigned int pcie_tx = 0; // KB/s + unsigned int pcie_rx = 0; }; namespace Nvml { diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 5a4d4c4..b40ab73 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -97,6 +97,7 @@ namespace Mem { namespace Gpu { gpu_info current_gpu; unsigned int device_count; + string gpu_name; //? NVIDIA data collection namespace Nvml { @@ -2093,7 +2094,7 @@ namespace Tools { namespace Gpu { //? NVIDIA - namespace Nvml { + namespace Nvml { // TODO: multi-GPU support bool init() { if (initialized) {return false;} @@ -2103,13 +2104,17 @@ namespace Gpu { return false; } - result = nvmlDeviceGetCount(&device_count); + //? Device count + unsigned int nvml_count; + result = nvmlDeviceGetCount(&nvml_count); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get device count: ") + nvmlErrorString(result)); return false; } + device_count += nvml_count; - result = nvmlDeviceGetHandleByIndex(0, &device); // TODO: multi-GPU support + //? Device Handle + result = nvmlDeviceGetHandleByIndex(0, &device); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get device handle: ") + nvmlErrorString(result)); return false; @@ -2117,16 +2122,30 @@ namespace Gpu { initialized = true; + //? Device name + char name[NVML_DEVICE_NAME_BUFFER_SIZE]; + result = nvmlDeviceGetName(device, name, NVML_DEVICE_NAME_BUFFER_SIZE); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get device name: ") + nvmlErrorString(result)); + } else {gpu_name = string(name);} + + //? Power usage + result = nvmlDeviceGetPowerManagementLimit(device, ¤t_gpu.pwr_max_usage); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get maximum GPU power draw, defaulting to 300W: ") + nvmlErrorString(result)); + } + //? Get temp_max - unsigned int temp_max; + unsigned int temp_max = 100; result = nvmlDeviceGetTemperatureThreshold(device, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN, &temp_max); if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get maximum GPU temperature: ") + nvmlErrorString(result)); + Logger::error(std::string("NVML: Failed to get maximum GPU temperature, defaulting to 100: ") + nvmlErrorString(result)); return false; } current_gpu.temp_max = (long long)temp_max; return true; } + bool shutdown() { if (!initialized) {return false;} @@ -2136,31 +2155,60 @@ namespace Gpu { } else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); return !initialized; } + bool collect(gpu_info& gpu) { if (!initialized) return false; - //? Get GPU utilization + //? GPU & memory utilization nvmlUtilization_t utilization; nvmlReturn_t result = nvmlDeviceGetUtilizationRates(device, &utilization); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get GPU utilization: ") + nvmlErrorString(result)); - return false; + } else { + gpu.gpu_percent.push_back((long long)utilization.gpu); + gpu.mem_utilization_percent.push_back((long long)utilization.memory); + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); + while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); } - gpu.gpu_percent.push_back((long long)utilization.gpu); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); - - //? GPU temp + + //? Clock speeds + result = nvmlDeviceGetClockInfo(device, NVML_CLOCK_GRAPHICS, ¤t_gpu.gpu_clock_speed); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU clock speed: ") + nvmlErrorString(result)); + } + result = nvmlDeviceGetClockInfo(device, NVML_CLOCK_MEM, ¤t_gpu.mem_clock_speed); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get VRAM clock speed: ") + nvmlErrorString(result)); + } + + //? Power usage & state + result = nvmlDeviceGetPowerUsage(device, ¤t_gpu.pwr_usage); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU power usage: ") + nvmlErrorString(result)); + } else { + current_gpu.pwr_percent.push_back(clamp((long long)round((double)current_gpu.pwr_usage * 100.0 / (double)current_gpu.pwr_max_usage), 0ll, 100ll)); + } + + nvmlPstates_t pState; + result = nvmlDeviceGetPowerState(device, &pState); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU power state: ") + nvmlErrorString(result)); + } else { + current_gpu.pwr_state = static_cast(pState); + } + + //? GPU temperature if (Config::getB("check_temp")) { unsigned int temp; nvmlReturn_t result = nvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &temp); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get GPU temperature: ") + nvmlErrorString(result)); - return false; - } - gpu.temp.push_back((long long)temp); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); + } else { + gpu.temp.push_back((long long)temp); + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); + } } //? Memory info @@ -2168,20 +2216,27 @@ namespace Gpu { result = nvmlDeviceGetMemoryInfo(device, &memory); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get VRAM info: ") + nvmlErrorString(result)); - return false; + } else { + gpu.mem_total = memory.total; + gpu.mem_used = memory.used; + //gpu.mem_free = memory.free; + + auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); + gpu.mem_used_percent.push_back(used_percent); + + //? Reduce size if there are more values than needed for graphs + while (cmp_greater(gpu.mem_used_percent.size(), width/2)) gpu.mem_used_percent.pop_front(); } - gpu.mem_total = memory.total; - gpu.mem_stats.at("used") = memory.used; - gpu.mem_stats.at("free") = memory.free; - - auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); - gpu.mem_percent.at("used").push_back(used_percent); - gpu.mem_percent.at("free").push_back(100-used_percent); - - //? Reduce size if there are more values than needed for graphs - while (cmp_greater(gpu.mem_percent.at("used").size(), width/2)) gpu.mem_percent.at("used").pop_front(); - while (cmp_greater(gpu.mem_percent.at("free").size(), width/2)) gpu.mem_percent.at("free").pop_front(); + //? PCIe link speeds + result = nvmlDeviceGetPcieThroughput(device, NVML_PCIE_UTIL_TX_BYTES, ¤t_gpu.pcie_tx); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get PCIe TX throughput: ") + nvmlErrorString(result)); + } + result = nvmlDeviceGetPcieThroughput(device, NVML_PCIE_UTIL_RX_BYTES, ¤t_gpu.pcie_rx); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get PCIe RX throughput: ") + nvmlErrorString(result)); + } return true; } From bcffcdf19f4d2cb774b916f43493ec7c051ac92a Mon Sep 17 00:00:00 2001 From: romner Date: Sun, 14 May 2023 16:53:06 +0200 Subject: [PATCH 093/209] Make GPU window's size dynamic and integrate it with the rest of btop --- src/btop.cpp | 40 ++--- src/btop_draw.cpp | 324 +++++++++++++++++++++---------------- src/btop_shared.hpp | 10 ++ src/btop_tools.cpp | 3 + src/linux/btop_collect.cpp | 11 ++ 5 files changed, 226 insertions(+), 162 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index dd189ea..ba8a24e 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -526,6 +526,26 @@ namespace Runner { } } + //? GPU + if (v_contains(conf.boxes, "gpu")) { + try { + if (Global::debug) debug_timer("gpu", collect_begin); + + //? Start collect + auto gpu = Gpu::collect(conf.no_update); + + if (Global::debug) debug_timer("gpu", draw_begin); + + //? Draw box + if (not pause_output) output += Gpu::draw(gpu, conf.force_redraw, conf.no_update); + + if (Global::debug) debug_timer("gpu", draw_done); + } + catch (const std::exception& e) { + throw std::runtime_error("Gpu:: -> " + string{e.what()}); + } + } + //? MEM if (v_contains(conf.boxes, "mem")) { try { @@ -586,26 +606,6 @@ namespace Runner { } } - //? GPU - if (v_contains(conf.boxes, "gpu")) { - try { - if (Global::debug) debug_timer("gpu", collect_begin); - - //? Start collect - auto gpu = Gpu::collect(conf.no_update); - - if (Global::debug) debug_timer("gpu", draw_begin); - - //? Draw box - if (not pause_output) output += Gpu::draw(gpu, conf.force_redraw, conf.no_update); - - if (Global::debug) debug_timer("gpu", draw_done); - } - catch (const std::exception& e) { - throw std::runtime_error("Gpu:: -> " + string{e.what()}); - } - } - } catch (const std::exception& e) { Global::exit_error_msg = "Exception in runner thread -> " + string{e.what()}; diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 1137fa1..55b1b10 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -727,6 +727,141 @@ namespace Cpu { } +namespace Gpu { + int width_p = 100, height_p = 32; + int min_width = 41, min_height = 9; + int x = 1, y = 1, width = 41, height; + int b_columns, b_column_size; + int b_x, b_y, b_width, b_height; + int bproc_x, bproc_y, bproc_width, bproc_height; + bool shown = true, redraw = true, mid_line = false; + int graph_up_height; + Draw::Graph graph_upper; + Draw::Graph graph_lower; + Draw::Graph temp_graph; + Draw::Graph mem_used_graph; + Draw::Graph mem_util_graph; + Draw::Meter gpu_meter; + Draw::Meter pwr_meter; + string box; + + string draw(const gpu_info& gpu, bool force_redraw, bool data_same) { + if (Runner::stopping) return ""; + if (force_redraw) redraw = true; + bool show_temps = (Config::getB("check_temp")); + auto tty_mode = Config::getB("tty_mode"); + auto& temp_scale = Config::getS("temp_scale"); + auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_cpu")); // TODO graph_symbol_gpu + auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); + auto single_graph = Config::getB("cpu_single_graph"); + string out; + out.reserve(width * height); + + + //* Redraw elements not needed to be updated every cycle + if (redraw) { + graph_up_height = single_graph ? height - 2 : ceil((double)(height - 2) / 2); + const int graph_low_height = height - 2 - graph_up_height - (mid_line ? 1 : 0); + out += box; + + graph_upper = Draw::Graph{x + width - b_width - 3, graph_up_height, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu + if (not single_graph) { + graph_lower = Draw::Graph{ + x + width - b_width - 3, + graph_low_height, "cpu", + gpu.gpu_percent, + graph_symbol, + Config::getB("cpu_invert_lower"), true + }; + } + + gpu_meter = Draw::Meter{b_width - (show_temps ? 24 : 11), "cpu"}; + temp_graph = Draw::Graph{6, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23}; + + pwr_meter = Draw::Meter{b_width - 24, "cached"}; + + mem_util_graph = Draw::Graph{b_width/2 - 1, 2, "free", gpu.mem_utilization_percent, graph_symbol, 0, 0, 100, 4}; // offset so the graph isn't empty at 0-5% I/O + mem_used_graph = Draw::Graph{b_width/2 - 2, 4, "used", gpu.mem_used_percent, graph_symbol}; + } + + + //* General GPU info + + //? Gpu graph, clock speed & meter + out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); + if (not single_graph) + out += Mv::to(y + graph_up_height + 1 + mid_line, x + 1) + graph_lower(gpu.gpu_percent, (data_same or redraw)); + + if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq + string clock_speed_string = to_string(gpu.gpu_clock_speed); + out += Mv::to(b_y, b_x + b_width - 12) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) + + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " Mhz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; + } + + out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "GPU " + gpu_meter(gpu.gpu_percent.back()) + + Theme::g("cpu").at(gpu.gpu_percent.back()) + rjust(to_string(gpu.gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; + + //? Temperature graph + if (show_temps) { + const auto [temp, unit] = celsius_to(gpu.temp.back(), temp_scale); + out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)) + + temp_graph(gpu.temp, data_same or redraw); + out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; + } + out += Theme::c("div_line") + Symbols::v_line; + + //? Power usage meter, power state + out += Mv::to(b_y + 2, b_x + 1) + Theme::c("main_fg") + Fx::b + "PWR " + pwr_meter(gpu.pwr_percent.back()) + + Theme::g("cached").at(gpu.pwr_percent.back()) + rjust(to_string(gpu.pwr_usage/1000), 4) + Theme::c("main_fg") + 'W' + + " P-state: " + (gpu.pwr_state > 9 ? "" : " ") + 'P' + Theme::g("cached").at(gpu.pwr_state) + to_string(gpu.pwr_state); + + //? Memory section header & clock speed + string used_memory_string = floating_humanizer(gpu.mem_used); + out += Mv::to(b_y + 3, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Fx::b + Theme::c("title") + "vram" + + Theme::c("div_line") + Fx::ub + Symbols::title_right + Symbols::h_line*(b_width/2-8) + Symbols::div_up + Symbols::h_line + + Theme::c("title") + "Used:" + Theme::c("div_line") + Symbols::h_line*(b_width/2+b_width%2-9-used_memory_string.size()) + Theme::c("title") + used_memory_string + Theme::c("div_line") + Symbols::h_line + Symbols::div_right; + if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq + string clock_speed_string = to_string(gpu.mem_clock_speed); + out += Mv::to(b_y + 3, b_x + b_width/2 - 11) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) + + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " Mhz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; + } + + //? Memory usage borders + out += Mv::to(b_y + 5, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "I/O:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-6) + + Symbols::div_right + Mv::u(1)+Mv::l(1) + Symbols::v_line + Mv::l(1)+Mv::d(2) + (Symbols::v_line + Mv::l(1)+Mv::d(1))*2; + + //? Total memory usage + out += Mv::to(b_y + 4, b_x + 2) + Theme::c("main_fg") + Fx::b + "Total:" + rjust(floating_humanizer(gpu.mem_total), b_width/2-9) + Fx::ub; + + //? Memory usage graphs & percentage + out += Mv::to(b_y+6, b_x+1) + Theme::c("inactive_fg") + mem_util_graph(gpu.mem_utilization_percent, (data_same or redraw)) + + Mv::u(3) + Mv::r(1) + mem_used_graph(gpu.mem_used_percent, (data_same or redraw)); + out += Mv::to(b_y+6, b_x+1) + rjust(to_string(gpu.mem_utilization_percent.back()), 3) + '%' + Mv::u(2) + Mv::r(b_width/2-3) + rjust(to_string(gpu.mem_used_percent.back()), 3) + '%'; + + //? Processes section header + //out += Mv::to(b_y+8, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Theme::c("main_fg") + Fx::b + "gpu-proc" + Fx::ub + Theme::c("div_line") + // + Symbols::title_right + Symbols::h_line*(b_width/2-12) + Symbols::div_down + Symbols::h_line*(b_width/2-2) + Symbols::div_right; + + //? PCIe link throughput + string tx_string = floating_humanizer(gpu.pcie_tx, 0, 1, 0, 1); + string rx_string = floating_humanizer(gpu.pcie_rx, 0, 1, 0, 1); + out += Mv::to(b_y + b_height - 1, b_x+2) + Theme::c("div_line") + + Symbols::title_left_down + Theme::c("title") + Fx::b + "TX:" + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*(b_width/2-9-tx_string.size()) + + Symbols::title_left_down + Theme::c("title") + Fx::b + tx_string + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::div_down + + Symbols::title_left_down + Theme::c("title") + Fx::b + "RX:" + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*(b_width/2+b_width%2-9-rx_string.size()) + + Symbols::title_left_down + Theme::c("title") + Fx::b + rx_string + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::round_right_down; + + //* GPU graphics process list + //! TODO + + //* GPU compute process list + //! TODO + + redraw = false; + return out + Fx::reset; + } +} + namespace Mem { int width_p = 45, height_p = 36; int min_width = 36, min_height = 10; @@ -1576,115 +1711,6 @@ namespace Proc { } -namespace Gpu { - int width_p = 100, height_p = 32; - int min_width = 60, min_height = 8; - int x = 1, y = 1, width = 20, height; - int b_columns, b_column_size; - int b_x, b_y, b_width, b_height; - bool shown = true, redraw = true, mid_line = false; - int graph_height; - Draw::Graph graph_upper; - Draw::Graph temp_graph; - Draw::Graph mem_used_graph; - Draw::Graph mem_util_graph; - Draw::Meter gpu_meter; - Draw::Meter pwr_meter; - string box; - - string draw(const gpu_info& gpu, bool force_redraw, bool data_same) { - if (Runner::stopping) return ""; - if (force_redraw) redraw = true; - bool show_temps = (Config::getB("check_temp")); - auto tty_mode = Config::getB("tty_mode"); - auto& temp_scale = Config::getS("temp_scale"); - auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_cpu")); // TODO graph_symbol_gpu - auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); - string out; - out.reserve(width * height); - - //* Redraw elements not needed to be updated every cycle - if (redraw) { - out += box; - - graph_upper = Draw::Graph{x + width - b_width - 3, height-2, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu - gpu_meter = Draw::Meter{b_width - (show_temps ? 24 : 11), "cpu"}; - temp_graph = Draw::Graph{6, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23}; - - pwr_meter = Draw::Meter{b_width - 24, "cached"}; - - mem_util_graph = Draw::Graph{b_width/2 - 1, 2, "free", gpu.mem_utilization_percent, graph_symbol, 0, 0, 100, 4}; // offset so the graph isn't empty at 0-5% I/O - mem_used_graph = Draw::Graph{b_width/2 - 2, 4, "used", gpu.mem_used_percent, graph_symbol}; - } - - //? Core text and graphs - try { - //? Gpu graph, clock speed & meter - out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); - - if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq - string clock_speed_string = to_string(gpu.gpu_clock_speed); - out += Mv::to(b_y, b_x + b_width - 12) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) - + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " Mhz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; - } - - out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "GPU " + gpu_meter(gpu.gpu_percent.back()) - + Theme::g("cpu").at(gpu.gpu_percent.back()) + rjust(to_string(gpu.gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; - - //? Temperature graph - if (show_temps) { - const auto [temp, unit] = celsius_to(gpu.temp.back(), temp_scale); - out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)) - + temp_graph(gpu.temp, data_same or redraw); - out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; - } - out += Theme::c("div_line") + Symbols::v_line; - - //? Power usage meter, power state - out += Mv::to(b_y + 2, b_x + 1) + Theme::c("main_fg") + Fx::b + "PWR " + pwr_meter(gpu.pwr_percent.back()) - + Theme::g("cached").at(gpu.pwr_percent.back()) + rjust(to_string(gpu.pwr_usage/1000), 4) + Theme::c("main_fg") + 'W' - + " P-state: " + (gpu.pwr_state > 9 ? "" : " ") + 'P' + Theme::g("cached").at(gpu.pwr_state) + to_string(gpu.pwr_state); - - //? Memory section header & clock speed - string used_memory_string = floating_humanizer(gpu.mem_used); - out += Mv::to(b_y + 3, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Fx::b + Theme::c("title") + "vram" - + Theme::c("div_line") + Fx::ub + Symbols::title_right + Symbols::h_line*(b_width/2-8) + Symbols::div_up + Symbols::h_line - + Theme::c("title") + "Used:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-9-used_memory_string.size()) + Theme::c("title") + used_memory_string + Theme::c("div_line") + Symbols::h_line + Symbols::div_right; - if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq - string clock_speed_string = to_string(gpu.mem_clock_speed); - out += Mv::to(b_y + 3, b_x + b_width/2 - 11) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) - + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " Mhz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; - } - - //? Memory usage borders - out += Mv::to(b_y + 5, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "I/O:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-6) - + Symbols::div_right + Mv::u(1)+Mv::l(1) + Symbols::v_line + Mv::l(1)+Mv::d(2) + (Symbols::v_line + Mv::l(1)+Mv::d(1))*2; - - //? Total memory usage - out += Mv::to(b_y + 4, b_x + 2) + Theme::c("main_fg") + Fx::b + "Total:" + rjust(floating_humanizer(gpu.mem_total), b_width/2-9) + Fx::ub; - - //? Memory usage graphs & percentage - out += Mv::to(b_y+6, b_x+1) + Theme::c("inactive_fg") + mem_util_graph(gpu.mem_utilization_percent, (data_same or redraw)) - + Mv::u(3) + Mv::r(1) + mem_used_graph(gpu.mem_used_percent, (data_same or redraw)); - out += Mv::to(b_y+6, b_x+1) + rjust(to_string(gpu.mem_utilization_percent.back()), 3) + '%' + Mv::u(2) + Mv::r(b_width/2-3) + rjust(to_string(gpu.mem_used_percent.back()), 3) + '%'; - - //? Processes section header - out += Mv::to(b_y+8, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Theme::c("main_fg") + Fx::b + "gpu-proc" + Fx::ub + Theme::c("div_line") - + Symbols::title_right + Symbols::h_line*(b_width/2-12) + Symbols::div_down + Symbols::h_line*(b_width/2-2) + Symbols::div_right; - - //? PCIe link throughput - out += Mv::to(b_y + b_height - 1, b_x+2) + Symbols::title_left_down + Theme::c("main_fg") + "TX: " + floating_humanizer(gpu.pcie_tx, 0, 1, 0, 1) + Theme::c("div_line") - + Symbols::title_right_down + Symbols::title_left_down + Theme::c("main_fg") + "RX: " + floating_humanizer(gpu.pcie_rx, 0, 1, 0, 1) + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*10; - - } catch (const std::exception& e) { - throw std::runtime_error("graphs: " + string{e.what()}); - } - - redraw = false; - return out + Fx::reset; - } -} - namespace Draw { void calcSizes() { atomic_wait(Runner::active); @@ -1695,10 +1721,10 @@ namespace Draw { auto proc_left = Config::getB("proc_left"); Cpu::box.clear(); + Gpu::box.clear(); Mem::box.clear(); Net::box.clear(); Proc::box.clear(); - Gpu::box.clear(); Global::clock.clear(); Global::overlay.clear(); Runner::pause_output = false; @@ -1709,24 +1735,29 @@ namespace Draw { Input::mouse_mappings.clear(); - Cpu::x = Mem::x = Net::x = Proc::y = Gpu::x = 1; - Cpu::y = Mem::y = Net::y = Proc::y = Gpu::y = 1; - Cpu::width = Mem::width = Net::width = Proc::width = Gpu::width = 0; - Cpu::height = Mem::height = Net::height = Proc::height = Gpu::height = 0; - Cpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = Gpu::redraw = true; + Cpu::x = Gpu::x = Mem::x = Net::x = Proc::y = 1; + Cpu::y = Gpu::y = Mem::y = Net::y = Proc::y = 1; + Cpu::width = Gpu::width = Mem::width = Net::width = Proc::width = 0; + Cpu::height = Gpu::height = Mem::height = Net::height = Proc::height = 0; + Cpu::redraw = Gpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; Cpu::shown = s_contains(boxes, "cpu"); + Gpu::shown = s_contains(boxes, "gpu"); Mem::shown = s_contains(boxes, "mem"); Net::shown = s_contains(boxes, "net"); Proc::shown = s_contains(boxes, "proc"); - Gpu::shown = s_contains(boxes, "gpu"); //* Calculate and draw cpu box outlines if (Cpu::shown) { using namespace Cpu; bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); - height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p) / 100)); + if (Gpu::shown && !(Mem::shown || Net::shown || Proc::shown)) { + height = Term::height/2; + } else { + height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + Gpu::shown*5) / 100)); + } + x = 1; y = cpu_bottom ? Term::height - height + 1 : 1; @@ -1760,6 +1791,33 @@ namespace Draw { box += createBox(b_x, b_y, b_width, b_height, "", false, cpu_title); } + //* Calculate and draw gpu box outlines + if (Gpu::shown) { + using namespace Gpu; + width = Term::width; + height = max(Gpu::min_height, Cpu::shown ? Cpu::height : (int)ceil((double)Term::height * (trim(boxes) == "gpu" ? 100 : height_p) / 100)); + x = 1; y = 1 + Cpu::shown*Cpu::height; + box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box + + b_height = 9; + b_width = clamp(width/2, min_width, b_height*6); + + // bproc_width = b_width; + // bproc_height = height-11; + + //? Main statistics box + b_x = x + width - b_width - 1; + b_y = y + ceil((double)(height - 2) / 2) - ceil((double)(b_height/*+bproc_height*/) / 2) + 1; + + box += createBox(b_x, b_y, b_width, b_height, "", false, gpu_name); + + //? TODO: Processes box + /*bproc_x = x + width - bproc_width - 1; + bproc_y = b_y + b_height; + + box += createBox(bproc_x, bproc_y, bproc_width, bproc_height, "", false, "gpu-proc");*/ + } + //* Calculate and draw mem box outlines if (Mem::shown) { using namespace Mem; @@ -1768,13 +1826,12 @@ namespace Draw { auto mem_graphs = Config::getB("mem_graphs"); width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); - height = ceil((double)Term::height * (100 - Cpu::height_p * Cpu::shown - Net::height_p * Net::shown) / 100) + 1; - if (height + Cpu::height > Term::height) height = Term::height - Cpu::height; + height = ceil((double)Term::height * (100 - Net::height_p * Net::shown*4 / ((Gpu::shown && Cpu::shown) + 4)) / 100) - Cpu::height - Gpu::height; x = (proc_left and Proc::shown) ? Term::width - width + 1: 1; if (mem_below_net and Net::shown) - y = Term::height - height + 1 - (cpu_bottom ? Cpu::height : 0); + y = Term::height - height + 1 - (cpu_bottom ? Cpu::height + Gpu::height : 0); else - y = cpu_bottom ? 1 : Cpu::height + 1; + y = cpu_bottom ? 1 : Cpu::height + Gpu::height + 1; if (show_disks) { mem_width = ceil((double)(width - 3) / 2); @@ -1823,10 +1880,10 @@ namespace Draw { if (Net::shown) { using namespace Net; width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); - height = Term::height - Cpu::height - Mem::height; + height = Term::height - Cpu::height - Gpu::height - Mem::height; x = (proc_left and Proc::shown) ? Term::width - width + 1 : 1; if (mem_below_net and Mem::shown) - y = cpu_bottom ? 1 : Cpu::height + 1; + y = cpu_bottom ? 1 : Cpu::height + Gpu::height + 1; else y = Term::height - height + 1 - (cpu_bottom ? Cpu::height : 0); @@ -1845,28 +1902,11 @@ namespace Draw { if (Proc::shown) { using namespace Proc; width = Term::width - (Mem::shown ? Mem::width : (Net::shown ? Net::width : 0)); - height = Term::height - Cpu::height; + height = Term::height - Cpu::height - Gpu::height; x = proc_left ? 1 : Term::width - width + 1; - y = (cpu_bottom and Cpu::shown) ? 1 : Cpu::height + 1; + y = (cpu_bottom and Cpu::shown) ? 1 : Cpu::height + Gpu::height + 1; select_max = height - 3; box = createBox(x, y, width, height, Theme::c("proc_box"), true, "proc", "", 4); } - - //* Calculate and draw gpu box outlines - if (Gpu::shown) { - using namespace Gpu; - width = Term::width; - height = Term::height; - x = 1; y = 1; - box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box - - b_width = width/2 - width%2; // TODO - b_height = height-2; - - b_x = x + width - b_width - 1; - b_y = y + ceil((double)(height - 2) / 2) - ceil((double)b_height / 2) + 1; - - box += createBox(b_x, b_y, b_width, b_height, "", false, gpu_name); - } } } diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 5c121be..5aff032 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -322,6 +322,13 @@ namespace Gpu { const array mem_names { "used"s, "free"s }; + //* Container for process information + struct proc_info { + unsigned int pid; + unsigned long long mem; + }; + + //* Per-device container for GPU info struct gpu_info { deque gpu_percent = {}; unsigned int gpu_clock_speed = 0; // MHz @@ -343,6 +350,9 @@ namespace Gpu { unsigned int pcie_tx = 0; // KB/s unsigned int pcie_rx = 0; + + vector graphics_processes = {}; + vector compute_processes = {}; }; namespace Nvml { diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 5789737..7f0d943 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -103,15 +103,18 @@ namespace Term { bool mem = boxes.find("mem") != string::npos; bool net = boxes.find("net") != string::npos; bool proc = boxes.find("proc") != string::npos; + bool gpu = boxes.find("gpu") != string::npos; int width = 0; if (mem) width = Mem::min_width; else if (net) width = Mem::min_width; width += (proc ? Proc::min_width : 0); if (cpu and width < Cpu::min_width) width = Cpu::min_width; + if (gpu and width < Gpu::min_width) width = Gpu::min_width; int height = (cpu ? Cpu::min_height : 0); if (proc) height += Proc::min_height; else height += (mem ? Mem::min_height : 0) + (net ? Net::min_height : 0); + if (gpu) height += Gpu::min_height; return { width, height }; } diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index b40ab73..fcb1275 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -2238,6 +2238,17 @@ namespace Gpu { Logger::error(std::string("NVML: Failed to get PCIe RX throughput: ") + nvmlErrorString(result)); } + //? TODO: Processes using GPU + /*unsigned int proc_info_len; + nvmlProcessInfo_t* proc_info = 0; + result = nvmlDeviceGetComputeRunningProcesses_v3(device, &proc_info_len, proc_info); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get compute processes: ") + nvmlErrorString(result)); + } else { + for (unsigned int i = 0; i < proc_info_len; ++i) + current_gpu.graphics_processes.push_back({proc_info[i].pid, proc_info[i].usedGpuMemory}); + }*/ + return true; } } From 0e0025a2c3dd521f9bcdb1bb9b0d76508a4663af Mon Sep 17 00:00:00 2001 From: romner Date: Sun, 14 May 2023 17:31:39 +0200 Subject: [PATCH 094/209] Update makefile text, fix typo and adhere to contibuting guidelines --- Makefile | 4 ++-- src/btop_draw.cpp | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index 14d2c5c..de08203 100644 --- a/Makefile +++ b/Makefile @@ -214,8 +214,8 @@ info: @printf "\033[1;93mLDCXXFLAGS \033[1;94m:| \033[0m$(LDCXXFLAGS)\n" @printf "\033[1;92mGPUCXXFLAGS \033[1;94m:| \033[0m$(GPUCXXFLAGS)\n" @printf "\033[1;92mGPULDFLAGS \033[1;94m:| \033[0m$(GPULDFLAGS)\n" - @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDCXX)\n" - @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDLD)\n" + @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) \$$(\033[92mGPUCXXFLAGS\033[37m) $(OLDCXX)\n" + @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) \$$(\033[92mGPULDFLAGS\033[37m) $(OLDLD)\n" info-quiet: @sleep 0.1 2>/dev/null || true diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 55b1b10..c81a3a4 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1735,7 +1735,7 @@ namespace Draw { Input::mouse_mappings.clear(); - Cpu::x = Gpu::x = Mem::x = Net::x = Proc::y = 1; + Cpu::x = Gpu::x = Mem::x = Net::x = Proc::x = 1; Cpu::y = Gpu::y = Mem::y = Net::y = Proc::y = 1; Cpu::width = Gpu::width = Mem::width = Net::width = Proc::width = 0; Cpu::height = Gpu::height = Mem::height = Net::height = Proc::height = 0; @@ -1752,7 +1752,7 @@ namespace Draw { using namespace Cpu; bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); - if (Gpu::shown && !(Mem::shown || Net::shown || Proc::shown)) { + if (Gpu::shown and !(Mem::shown or Net::shown or Proc::shown)) { height = Term::height/2; } else { height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + Gpu::shown*5) / 100)); @@ -1826,7 +1826,7 @@ namespace Draw { auto mem_graphs = Config::getB("mem_graphs"); width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); - height = ceil((double)Term::height * (100 - Net::height_p * Net::shown*4 / ((Gpu::shown && Cpu::shown) + 4)) / 100) - Cpu::height - Gpu::height; + height = ceil((double)Term::height * (100 - Net::height_p * Net::shown*4 / ((Gpu::shown and Cpu::shown) + 4)) / 100) - Cpu::height - Gpu::height; x = (proc_left and Proc::shown) ? Term::width - width + 1: 1; if (mem_below_net and Net::shown) y = Term::height - height + 1 - (cpu_bottom ? Cpu::height + Gpu::height : 0); From 2d27f2ff610d4894997ffbcede70ed5f716a4f94 Mon Sep 17 00:00:00 2001 From: romner Date: Sun, 14 May 2023 17:40:50 +0200 Subject: [PATCH 095/209] Fix crash when no nvidia GPU is detected --- src/btop.cpp | 2 +- src/btop_draw.cpp | 2 +- src/btop_tools.cpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index ba8a24e..ab5eafa 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -537,7 +537,7 @@ namespace Runner { if (Global::debug) debug_timer("gpu", draw_begin); //? Draw box - if (not pause_output) output += Gpu::draw(gpu, conf.force_redraw, conf.no_update); + if (not pause_output and Gpu::Nvml::initialized) output += Gpu::draw(gpu, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("gpu", draw_done); } diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index c81a3a4..25224ac 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -1742,7 +1742,7 @@ namespace Draw { Cpu::redraw = Gpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; Cpu::shown = s_contains(boxes, "cpu"); - Gpu::shown = s_contains(boxes, "gpu"); + Gpu::shown = s_contains(boxes, "gpu") and Gpu::Nvml::initialized; Mem::shown = s_contains(boxes, "mem"); Net::shown = s_contains(boxes, "net"); Proc::shown = s_contains(boxes, "proc"); diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 7f0d943..6443b89 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -103,7 +103,7 @@ namespace Term { bool mem = boxes.find("mem") != string::npos; bool net = boxes.find("net") != string::npos; bool proc = boxes.find("proc") != string::npos; - bool gpu = boxes.find("gpu") != string::npos; + bool gpu = boxes.find("gpu") != string::npos and Gpu::Nvml::initialized; int width = 0; if (mem) width = Mem::min_width; else if (net) width = Mem::min_width; From 917d568a77b9e693a6d6a2c7fab57f957eff988d Mon Sep 17 00:00:00 2001 From: romner-set Date: Mon, 15 May 2023 13:58:54 +0200 Subject: [PATCH 096/209] Add multi-GPU support for NVML data collection --- src/btop.cpp | 4 +- src/btop_draw.cpp | 6 +- src/btop_shared.hpp | 18 +- src/linux/btop_collect.cpp | 374 +++++++++++++++++++------------------ 4 files changed, 204 insertions(+), 198 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index ab5eafa..96e178d 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -532,12 +532,12 @@ namespace Runner { if (Global::debug) debug_timer("gpu", collect_begin); //? Start collect - auto gpu = Gpu::collect(conf.no_update); + auto gpus = Gpu::collect(conf.no_update); if (Global::debug) debug_timer("gpu", draw_begin); //? Draw box - if (not pause_output and Gpu::Nvml::initialized) output += Gpu::draw(gpu, conf.force_redraw, conf.no_update); + if (not pause_output and Gpu::Nvml::initialized) output += Gpu::draw(gpus, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("gpu", draw_done); } diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 25224ac..ccbaec4 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -745,7 +745,7 @@ namespace Gpu { Draw::Meter pwr_meter; string box; - string draw(const gpu_info& gpu, bool force_redraw, bool data_same) { + string draw(const vector& gpus, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; bool show_temps = (Config::getB("check_temp")); @@ -757,6 +757,7 @@ namespace Gpu { string out; out.reserve(width * height); + auto gpu = gpus[0]; // TODO: mutli-gpu support //* Redraw elements not needed to be updated every cycle if (redraw) { @@ -1796,6 +1797,7 @@ namespace Draw { using namespace Gpu; width = Term::width; height = max(Gpu::min_height, Cpu::shown ? Cpu::height : (int)ceil((double)Term::height * (trim(boxes) == "gpu" ? 100 : height_p) / 100)); + height += height+Cpu::height == Term::height-1; x = 1; y = 1 + Cpu::shown*Cpu::height; box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box @@ -1809,7 +1811,7 @@ namespace Draw { b_x = x + width - b_width - 1; b_y = y + ceil((double)(height - 2) / 2) - ceil((double)(b_height/*+bproc_height*/) / 2) + 1; - box += createBox(b_x, b_y, b_width, b_height, "", false, gpu_name); + box += createBox(b_x, b_y, b_width, b_height, "", false, gpu_names[0]); //? TODO: Processes box /*bproc_x = x + width - bproc_width - 1; diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 5aff032..b0f7dec 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -318,15 +318,15 @@ namespace Gpu { extern string box; extern int x, y, width, height, min_width, min_height; extern bool shown, redraw; - extern string gpu_name; + extern vector gpu_names; const array mem_names { "used"s, "free"s }; - //* Container for process information - struct proc_info { + //* Container for process information // TODO + /*struct proc_info { unsigned int pid; unsigned long long mem; - }; + };*/ //* Per-device container for GPU info struct gpu_info { @@ -351,8 +351,8 @@ namespace Gpu { unsigned int pcie_tx = 0; // KB/s unsigned int pcie_rx = 0; - vector graphics_processes = {}; - vector compute_processes = {}; + // vector graphics_processes = {}; // TODO + // vector compute_processes = {}; }; namespace Nvml { @@ -361,8 +361,8 @@ namespace Gpu { } //* Collect gpu stats and temperatures - auto collect(bool no_update = false) -> gpu_info&; + auto collect(bool no_update = false) -> vector&; - //* Draw contents of gpu box using as source - string draw(const gpu_info& gpu, bool force_redraw, bool data_same); + //* Draw contents of gpu box using as source + string draw(const vector& gpus, bool force_redraw, bool data_same); } diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index fcb1275..fb6e566 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -90,24 +90,24 @@ namespace Cpu { unordered_flat_map core_mapping; } -namespace Mem { - double old_uptime; -} - namespace Gpu { - gpu_info current_gpu; - unsigned int device_count; - string gpu_name; + vector gpus; + vector gpu_names; //? NVIDIA data collection namespace Nvml { bool initialized = false; bool init(); bool shutdown(); - nvmlDevice_t device; + vector devices; + unsigned int device_count = 0; } } +namespace Mem { + double old_uptime; +} + namespace Shared { fs::path procPath, passwd_path; @@ -172,6 +172,7 @@ namespace Shared { } + } namespace Cpu { @@ -825,6 +826,186 @@ namespace Cpu { } } +namespace Gpu { + //? NVIDIA + namespace Nvml { + bool init() { + if (initialized) {return false;} + + nvmlReturn_t result = nvmlInit(); + if (result != NVML_SUCCESS) { + Logger::warning(std::string("Failed to initialize NVML, NVIDIA GPUs will not be detected: ") + nvmlErrorString(result)); + return false; + } + + //? Device count + result = nvmlDeviceGetCount(&device_count); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get device count: ") + nvmlErrorString(result)); + return false; + } + + if (device_count > 0) { + devices.resize(device_count); + gpus.resize(device_count); + gpu_names.resize(device_count); + + for (unsigned int i = 0; i < device_count; ++i) { + //? Device Handle + result = nvmlDeviceGetHandleByIndex(i, devices.data() + i*sizeof(nvmlDevice_t)); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get device handle: ") + nvmlErrorString(result)); + return false; + } + + initialized = true; + + //? Device name + char name[NVML_DEVICE_NAME_BUFFER_SIZE]; + result = nvmlDeviceGetName(devices[i], name, NVML_DEVICE_NAME_BUFFER_SIZE); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get device name: ") + nvmlErrorString(result)); + } else {gpu_names[i] = string(name);} + + //? Power usage + result = nvmlDeviceGetPowerManagementLimit(devices[i], &gpus[i].pwr_max_usage); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get maximum GPU power draw, defaulting to 300W: ") + nvmlErrorString(result)); + } + + //? Get temp_max + unsigned int temp_max = 100; + result = nvmlDeviceGetTemperatureThreshold(devices[i], NVML_TEMPERATURE_THRESHOLD_SHUTDOWN, &temp_max); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get maximum GPU temperature, defaulting to 100: ") + nvmlErrorString(result)); + } + gpus[i].temp_max = (long long)temp_max; + } + return true; + } else {initialized = true; shutdown(); return false;} + } + + bool shutdown() { + if (!initialized) {return false;} + + nvmlReturn_t result = nvmlShutdown(); + if (NVML_SUCCESS == result) { + initialized = false; + } else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); + return !initialized; + } + + bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count, defined in init() + if (!initialized) return false; + + for (unsigned int i = 0; i < device_count; ++i) { + //? GPU & memory utilization + nvmlUtilization_t utilization; + nvmlReturn_t result = nvmlDeviceGetUtilizationRates(devices[i], &utilization); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU utilization: ") + nvmlErrorString(result)); + } else { + gpus_slice[i].gpu_percent.push_back((long long)utilization.gpu); + gpus_slice[i].mem_utilization_percent.push_back((long long)utilization.memory); + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpus_slice[i].gpu_percent.size(), width * 2)) gpus_slice[i].gpu_percent.pop_front(); + while (cmp_greater(gpus_slice[i].mem_utilization_percent.size(), width)) gpus_slice[i].mem_utilization_percent.pop_front(); + } + + //? Clock speeds + result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_GRAPHICS, &gpus_slice[i].gpu_clock_speed); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU clock speed: ") + nvmlErrorString(result)); + } + result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_MEM, &gpus_slice[i].mem_clock_speed); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get VRAM clock speed: ") + nvmlErrorString(result)); + } + + //? Power usage & state + result = nvmlDeviceGetPowerUsage(devices[i], &gpus_slice[i].pwr_usage); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU power usage: ") + nvmlErrorString(result)); + } else { + gpus_slice[i].pwr_percent.push_back(clamp((long long)round((double)gpus_slice[i].pwr_usage * 100.0 / (double)gpus_slice[i].pwr_max_usage), 0ll, 100ll)); + } + + nvmlPstates_t pState; + result = nvmlDeviceGetPowerState(devices[i], &pState); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU power state: ") + nvmlErrorString(result)); + } else { + gpus_slice[i].pwr_state = static_cast(pState); + } + + //? GPU temperature + if (Config::getB("check_temp")) { + unsigned int temp; + nvmlReturn_t result = nvmlDeviceGetTemperature(devices[i], NVML_TEMPERATURE_GPU, &temp); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get GPU temperature: ") + nvmlErrorString(result)); + } else { + gpus_slice[i].temp.push_back((long long)temp); + //? Reduce size if there are more values than needed for graph + while (cmp_greater(gpus_slice[i].temp.size(), 18)) gpus_slice[i].temp.pop_front(); + } + } + + //? Memory info + nvmlMemory_t memory; + result = nvmlDeviceGetMemoryInfo(devices[i], &memory); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get VRAM info: ") + nvmlErrorString(result)); + } else { + gpus_slice[i].mem_total = memory.total; + gpus_slice[i].mem_used = memory.used; + //gpu.mem_free = memory.free; + + auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); + gpus_slice[i].mem_used_percent.push_back(used_percent); + + //? Reduce size if there are more values than needed for graphs + while (cmp_greater(gpus_slice[i].mem_used_percent.size(), width/2)) gpus_slice[i].mem_used_percent.pop_front(); + } + + //? PCIe link speeds + result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_TX_BYTES, &gpus_slice[i].pcie_tx); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get PCIe TX throughput: ") + nvmlErrorString(result)); + } + result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_RX_BYTES, &gpus_slice[i].pcie_rx); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get PCIe RX throughput: ") + nvmlErrorString(result)); + } + + //? TODO: Processes using GPU + /*unsigned int proc_info_len; + nvmlProcessInfo_t* proc_info = 0; + result = nvmlDeviceGetComputeRunningProcesses_v3(device, &proc_info_len, proc_info); + if (result != NVML_SUCCESS) { + Logger::error(std::string("NVML: Failed to get compute processes: ") + nvmlErrorString(result)); + } else { + for (unsigned int i = 0; i < proc_info_len; ++i) + gpus_slice[i].graphics_processes.push_back({proc_info[i].pid, proc_info[i].usedGpuMemory}); + }*/ + } + + return true; + } + } + // TODO: AMD + // TODO: Intel + + //? Collect data from GPU-specific libraries + auto collect(bool no_update) -> vector& { + if (Runner::stopping or (no_update and not gpus.empty())) return gpus; + + Nvml::collect(gpus.data()); // raw pointer to array data, size == Nvml::device_count, defined in Nvml::init() + + return gpus; + } +} + namespace Mem { bool has_swap{}; // defaults to false vector fstab; @@ -2091,180 +2272,3 @@ namespace Tools { throw std::runtime_error("Failed get uptime from " + string{Shared::procPath} + "/uptime"); } } - -namespace Gpu { - //? NVIDIA - namespace Nvml { // TODO: multi-GPU support - bool init() { - if (initialized) {return false;} - - nvmlReturn_t result = nvmlInit(); - if (result != NVML_SUCCESS) { - Logger::warning(std::string("Failed to initialize NVML, NVIDIA GPUs will not be detected: ") + nvmlErrorString(result)); - return false; - } - - //? Device count - unsigned int nvml_count; - result = nvmlDeviceGetCount(&nvml_count); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get device count: ") + nvmlErrorString(result)); - return false; - } - device_count += nvml_count; - - //? Device Handle - result = nvmlDeviceGetHandleByIndex(0, &device); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get device handle: ") + nvmlErrorString(result)); - return false; - } - - initialized = true; - - //? Device name - char name[NVML_DEVICE_NAME_BUFFER_SIZE]; - result = nvmlDeviceGetName(device, name, NVML_DEVICE_NAME_BUFFER_SIZE); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get device name: ") + nvmlErrorString(result)); - } else {gpu_name = string(name);} - - //? Power usage - result = nvmlDeviceGetPowerManagementLimit(device, ¤t_gpu.pwr_max_usage); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get maximum GPU power draw, defaulting to 300W: ") + nvmlErrorString(result)); - } - - //? Get temp_max - unsigned int temp_max = 100; - result = nvmlDeviceGetTemperatureThreshold(device, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN, &temp_max); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get maximum GPU temperature, defaulting to 100: ") + nvmlErrorString(result)); - return false; - } - current_gpu.temp_max = (long long)temp_max; - return true; - } - - bool shutdown() { - if (!initialized) {return false;} - - nvmlReturn_t result = nvmlShutdown(); - if (NVML_SUCCESS == result) { - initialized = true; - } else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); - return !initialized; - } - - bool collect(gpu_info& gpu) { - if (!initialized) return false; - - //? GPU & memory utilization - nvmlUtilization_t utilization; - nvmlReturn_t result = nvmlDeviceGetUtilizationRates(device, &utilization); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get GPU utilization: ") + nvmlErrorString(result)); - } else { - gpu.gpu_percent.push_back((long long)utilization.gpu); - gpu.mem_utilization_percent.push_back((long long)utilization.memory); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); - while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); - } - - //? Clock speeds - result = nvmlDeviceGetClockInfo(device, NVML_CLOCK_GRAPHICS, ¤t_gpu.gpu_clock_speed); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get GPU clock speed: ") + nvmlErrorString(result)); - } - result = nvmlDeviceGetClockInfo(device, NVML_CLOCK_MEM, ¤t_gpu.mem_clock_speed); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get VRAM clock speed: ") + nvmlErrorString(result)); - } - - //? Power usage & state - result = nvmlDeviceGetPowerUsage(device, ¤t_gpu.pwr_usage); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get GPU power usage: ") + nvmlErrorString(result)); - } else { - current_gpu.pwr_percent.push_back(clamp((long long)round((double)current_gpu.pwr_usage * 100.0 / (double)current_gpu.pwr_max_usage), 0ll, 100ll)); - } - - nvmlPstates_t pState; - result = nvmlDeviceGetPowerState(device, &pState); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get GPU power state: ") + nvmlErrorString(result)); - } else { - current_gpu.pwr_state = static_cast(pState); - } - - //? GPU temperature - if (Config::getB("check_temp")) { - unsigned int temp; - nvmlReturn_t result = nvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &temp); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get GPU temperature: ") + nvmlErrorString(result)); - } else { - gpu.temp.push_back((long long)temp); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); - } - } - - //? Memory info - nvmlMemory_t memory; - result = nvmlDeviceGetMemoryInfo(device, &memory); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get VRAM info: ") + nvmlErrorString(result)); - } else { - gpu.mem_total = memory.total; - gpu.mem_used = memory.used; - //gpu.mem_free = memory.free; - - auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); - gpu.mem_used_percent.push_back(used_percent); - - //? Reduce size if there are more values than needed for graphs - while (cmp_greater(gpu.mem_used_percent.size(), width/2)) gpu.mem_used_percent.pop_front(); - } - - //? PCIe link speeds - result = nvmlDeviceGetPcieThroughput(device, NVML_PCIE_UTIL_TX_BYTES, ¤t_gpu.pcie_tx); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get PCIe TX throughput: ") + nvmlErrorString(result)); - } - result = nvmlDeviceGetPcieThroughput(device, NVML_PCIE_UTIL_RX_BYTES, ¤t_gpu.pcie_rx); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get PCIe RX throughput: ") + nvmlErrorString(result)); - } - - //? TODO: Processes using GPU - /*unsigned int proc_info_len; - nvmlProcessInfo_t* proc_info = 0; - result = nvmlDeviceGetComputeRunningProcesses_v3(device, &proc_info_len, proc_info); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get compute processes: ") + nvmlErrorString(result)); - } else { - for (unsigned int i = 0; i < proc_info_len; ++i) - current_gpu.graphics_processes.push_back({proc_info[i].pid, proc_info[i].usedGpuMemory}); - }*/ - - return true; - } - } - // TODO: AMD - // TODO: Intel - - //? Collect data from GPU-specific libraries - auto collect(bool no_update) -> gpu_info& { - if (Runner::stopping or (no_update and not current_gpu.gpu_percent.empty())) return current_gpu; - auto& gpu = current_gpu; - - //if (Config::getB("show_gpu_freq")) - // TODO gpuHz = get_gpuHz(); - - Nvml::collect(gpu); - - return gpu; - } -} From c352bf26137daa0d242fa52ef11ecd6550bf0823 Mon Sep 17 00:00:00 2001 From: romner-set Date: Mon, 15 May 2023 19:42:55 +0200 Subject: [PATCH 097/209] Add ROCm SMI backend for AMD GPU support --- Makefile | 4 +- src/btop.cpp | 3 +- src/btop_draw.cpp | 15 ++- src/btop_shared.hpp | 29 ++-- src/btop_tools.cpp | 2 +- src/linux/btop_collect.cpp | 269 +++++++++++++++++++++++++++++-------- 6 files changed, 243 insertions(+), 79 deletions(-) diff --git a/Makefile b/Makefile index de08203..a64a2e5 100644 --- a/Makefile +++ b/Makefile @@ -164,8 +164,8 @@ override REQFLAGS := -std=c++20 WARNFLAGS := -Wall -Wextra -pedantic OPTFLAGS := -O2 -ftree-vectorize -flto=$(LTO) LDCXXFLAGS := -pthread -D_FORTIFY_SOURCE=2 -D_GLIBCXX_ASSERTIONS -D_FILE_OFFSET_BITS=64 $(GOODFLAGS) $(ADDFLAGS) -GPUCXXFLAGS := -I/opt/cuda/include # TODO: there has to be a better way to link NVML than hardcoded dirs -GPULDFLAGS := -L/usr/lib64 -lnvidia-ml +GPUCXXFLAGS := -I/opt/cuda/include -I/opt/rocm/include # TODO: there has to be a better way to link these libs than hardcoded dirs +GPULDFLAGS := -L/opt/cuda/lib -L/opt/rocm/lib -lnvidia-ml -lrocm_smi64 override CXXFLAGS += $(REQFLAGS) $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) $(GPUCXXFLAGS) override LDFLAGS += $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) $(GPULDFLAGS) INC := $(foreach incdir,$(INCDIRS),-isystem $(incdir)) -I$(SRCDIR) diff --git a/src/btop.cpp b/src/btop.cpp index 96e178d..f081d5d 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -262,6 +262,7 @@ void clean_quit(int sig) { } Gpu::Nvml::shutdown(); + Gpu::Rsmi::shutdown(); Config::write(); @@ -537,7 +538,7 @@ namespace Runner { if (Global::debug) debug_timer("gpu", draw_begin); //? Draw box - if (not pause_output and Gpu::Nvml::initialized) output += Gpu::draw(gpus, conf.force_redraw, conf.no_update); + if (not pause_output and not Gpu::gpu_names.empty()) output += Gpu::draw(gpus, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("gpu", draw_done); } diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index ccbaec4..4baf9dd 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -757,7 +757,7 @@ namespace Gpu { string out; out.reserve(width * height); - auto gpu = gpus[0]; // TODO: mutli-gpu support + auto gpu = gpus[0]; // TODO: multi-gpu support //* Redraw elements not needed to be updated every cycle if (redraw) { @@ -781,7 +781,7 @@ namespace Gpu { pwr_meter = Draw::Meter{b_width - 24, "cached"}; - mem_util_graph = Draw::Graph{b_width/2 - 1, 2, "free", gpu.mem_utilization_percent, graph_symbol, 0, 0, 100, 4}; // offset so the graph isn't empty at 0-5% I/O + mem_util_graph = Draw::Graph{b_width/2 - 1, 2, "free", gpu.mem_utilization_percent, graph_symbol, 0, 0, 100, 4}; // offset so the graph isn't empty at 0-5% utilization mem_used_graph = Draw::Graph{b_width/2 - 2, 4, "used", gpu.mem_used_percent, graph_symbol}; } @@ -813,8 +813,9 @@ namespace Gpu { //? Power usage meter, power state out += Mv::to(b_y + 2, b_x + 1) + Theme::c("main_fg") + Fx::b + "PWR " + pwr_meter(gpu.pwr_percent.back()) - + Theme::g("cached").at(gpu.pwr_percent.back()) + rjust(to_string(gpu.pwr_usage/1000), 4) + Theme::c("main_fg") + 'W' - + " P-state: " + (gpu.pwr_state > 9 ? "" : " ") + 'P' + Theme::g("cached").at(gpu.pwr_state) + to_string(gpu.pwr_state); + + Theme::g("cached").at(gpu.pwr_percent.back()) + rjust(to_string(gpu.pwr_usage/1000), 4) + Theme::c("main_fg") + 'W'; + if (gpu.pwr_state != 32) // NVML_PSTATE_UNKNOWN; unsupported or non-nvidia card + out += std::string(" P-state: ") + (gpu.pwr_state > 9 ? "" : " ") + 'P' + Theme::g("cached").at(gpu.pwr_state) + to_string(gpu.pwr_state); //? Memory section header & clock speed string used_memory_string = floating_humanizer(gpu.mem_used); @@ -828,7 +829,7 @@ namespace Gpu { } //? Memory usage borders - out += Mv::to(b_y + 5, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "I/O:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-6) + out += Mv::to(b_y + 5, b_x) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "Utilization:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-14) + Symbols::div_right + Mv::u(1)+Mv::l(1) + Symbols::v_line + Mv::l(1)+Mv::d(2) + (Symbols::v_line + Mv::l(1)+Mv::d(1))*2; //? Total memory usage @@ -1743,7 +1744,7 @@ namespace Draw { Cpu::redraw = Gpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; Cpu::shown = s_contains(boxes, "cpu"); - Gpu::shown = s_contains(boxes, "gpu") and Gpu::Nvml::initialized; + Gpu::shown = s_contains(boxes, "gpu") and not Gpu::gpu_names.empty(); Mem::shown = s_contains(boxes, "mem"); Net::shown = s_contains(boxes, "net"); Proc::shown = s_contains(boxes, "proc"); @@ -1753,7 +1754,7 @@ namespace Draw { using namespace Cpu; bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); - if (Gpu::shown and !(Mem::shown or Net::shown or Proc::shown)) { + if (Gpu::shown and not (Mem::shown or Net::shown or Proc::shown)) { height = Term::height/2; } else { height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + Gpu::shown*5) / 100)); diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index b0f7dec..589536b 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -330,33 +330,34 @@ namespace Gpu { //* Per-device container for GPU info struct gpu_info { - deque gpu_percent = {}; + deque gpu_percent = {0}; unsigned int gpu_clock_speed = 0; // MHz - deque pwr_percent = {}; - unsigned int pwr_usage = 0; // mW - unsigned int pwr_max_usage = 300000; - unsigned int pwr_state = 32; + deque pwr_percent = {0}; + long long pwr_usage = 0; // mW + long long pwr_max_usage = 255000; + long long pwr_state = 32; - deque temp = {}; - long long temp_max = 100; + deque temp = {0}; + long long temp_max = 110; long long mem_total = 0; long long mem_used = 0; - deque mem_used_percent = {}; - long long mem_utilization = 0; - deque mem_utilization_percent = {}; - unsigned int mem_clock_speed = 0; // MHz + deque mem_used_percent = {0}; + deque mem_utilization_percent = {0}; // TODO: properly handle GPUs that can't report some stats + long long mem_clock_speed = 0; // MHz - unsigned int pcie_tx = 0; // KB/s - unsigned int pcie_rx = 0; + long long pcie_tx = 0; // KB/s + long long pcie_rx = 0; // vector graphics_processes = {}; // TODO // vector compute_processes = {}; }; namespace Nvml { - extern bool initialized; + extern bool shutdown(); + } + namespace Rsmi { extern bool shutdown(); } diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 6443b89..9f61ff9 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -103,7 +103,7 @@ namespace Term { bool mem = boxes.find("mem") != string::npos; bool net = boxes.find("net") != string::npos; bool proc = boxes.find("proc") != string::npos; - bool gpu = boxes.find("gpu") != string::npos and Gpu::Nvml::initialized; + bool gpu = boxes.find("gpu") != string::npos and not Gpu::gpu_names.empty(); int width = 0; if (mem) width = Mem::min_width; else if (net) width = Mem::min_width; diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index fb6e566..bb47aeb 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -29,6 +29,7 @@ tab-size = 4 #include #include // for inet_ntop() #include +#include #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) @@ -102,6 +103,14 @@ namespace Gpu { vector devices; unsigned int device_count = 0; } + + //? AMD data collection + namespace Rsmi { + bool initialized = false; + bool init(); + bool shutdown(); + uint32_t device_count = 0; + } } namespace Mem { @@ -169,10 +178,8 @@ namespace Shared { //? Init for namespace Gpu Gpu::Nvml::init(); - + Gpu::Rsmi::init(); } - - } namespace Cpu { @@ -830,7 +837,7 @@ namespace Gpu { //? NVIDIA namespace Nvml { bool init() { - if (initialized) {return false;} + if (initialized) return false; nvmlReturn_t result = nvmlInit(); if (result != NVML_SUCCESS) { @@ -855,100 +862,97 @@ namespace Gpu { result = nvmlDeviceGetHandleByIndex(i, devices.data() + i*sizeof(nvmlDevice_t)); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get device handle: ") + nvmlErrorString(result)); - return false; + continue; } - initialized = true; - //? Device name char name[NVML_DEVICE_NAME_BUFFER_SIZE]; result = nvmlDeviceGetName(devices[i], name, NVML_DEVICE_NAME_BUFFER_SIZE); - if (result != NVML_SUCCESS) { + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get device name: ") + nvmlErrorString(result)); - } else {gpu_names[i] = string(name);} + else gpu_names[i] = string(name); //? Power usage - result = nvmlDeviceGetPowerManagementLimit(devices[i], &gpus[i].pwr_max_usage); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get maximum GPU power draw, defaulting to 300W: ") + nvmlErrorString(result)); - } + unsigned int max_power; + result = nvmlDeviceGetPowerManagementLimit(devices[i], &max_power); + if (result != NVML_SUCCESS) + Logger::error(std::string("NVML: Failed to get maximum GPU power draw, defaulting to 225W: ") + nvmlErrorString(result)); + else gpus[i].pwr_max_usage = max_power; //? Get temp_max - unsigned int temp_max = 100; + unsigned int temp_max; result = nvmlDeviceGetTemperatureThreshold(devices[i], NVML_TEMPERATURE_THRESHOLD_SHUTDOWN, &temp_max); - if (result != NVML_SUCCESS) { - Logger::error(std::string("NVML: Failed to get maximum GPU temperature, defaulting to 100: ") + nvmlErrorString(result)); - } - gpus[i].temp_max = (long long)temp_max; + if (result != NVML_SUCCESS) + Logger::error(std::string("NVML: Failed to get maximum GPU temperature, defaulting to 110: ") + nvmlErrorString(result)); + else gpus[i].temp_max = (long long)temp_max; } + initialized = true; + return true; } else {initialized = true; shutdown(); return false;} } bool shutdown() { - if (!initialized) {return false;} + if (!initialized) return false; nvmlReturn_t result = nvmlShutdown(); - if (NVML_SUCCESS == result) { + if (NVML_SUCCESS == result) initialized = false; - } else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); + else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); + return !initialized; } - bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count, defined in init() + bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count if (!initialized) return false; + nvmlReturn_t result; for (unsigned int i = 0; i < device_count; ++i) { //? GPU & memory utilization nvmlUtilization_t utilization; - nvmlReturn_t result = nvmlDeviceGetUtilizationRates(devices[i], &utilization); + result = nvmlDeviceGetUtilizationRates(devices[i], &utilization); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get GPU utilization: ") + nvmlErrorString(result)); } else { gpus_slice[i].gpu_percent.push_back((long long)utilization.gpu); gpus_slice[i].mem_utilization_percent.push_back((long long)utilization.memory); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpus_slice[i].gpu_percent.size(), width * 2)) gpus_slice[i].gpu_percent.pop_front(); - while (cmp_greater(gpus_slice[i].mem_utilization_percent.size(), width)) gpus_slice[i].mem_utilization_percent.pop_front(); } //? Clock speeds - result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_GRAPHICS, &gpus_slice[i].gpu_clock_speed); - if (result != NVML_SUCCESS) { + unsigned int gpu_clock, mem_clock; + result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_GRAPHICS, &gpu_clock); + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get GPU clock speed: ") + nvmlErrorString(result)); - } - result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_MEM, &gpus_slice[i].mem_clock_speed); - if (result != NVML_SUCCESS) { + else gpus_slice[i].gpu_clock_speed = (long long)gpu_clock; + + result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_MEM, &mem_clock); + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get VRAM clock speed: ") + nvmlErrorString(result)); - } + else gpus_slice[i].mem_clock_speed = (long long)mem_clock; //? Power usage & state - result = nvmlDeviceGetPowerUsage(devices[i], &gpus_slice[i].pwr_usage); + unsigned int power; + result = nvmlDeviceGetPowerUsage(devices[i], &power); if (result != NVML_SUCCESS) { Logger::error(std::string("NVML: Failed to get GPU power usage: ") + nvmlErrorString(result)); } else { + gpus_slice[i].pwr_usage = (long long)power; gpus_slice[i].pwr_percent.push_back(clamp((long long)round((double)gpus_slice[i].pwr_usage * 100.0 / (double)gpus_slice[i].pwr_max_usage), 0ll, 100ll)); } nvmlPstates_t pState; result = nvmlDeviceGetPowerState(devices[i], &pState); - if (result != NVML_SUCCESS) { + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get GPU power state: ") + nvmlErrorString(result)); - } else { - gpus_slice[i].pwr_state = static_cast(pState); - } + else gpus_slice[i].pwr_state = static_cast(pState); //? GPU temperature if (Config::getB("check_temp")) { unsigned int temp; nvmlReturn_t result = nvmlDeviceGetTemperature(devices[i], NVML_TEMPERATURE_GPU, &temp); - if (result != NVML_SUCCESS) { + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get GPU temperature: ") + nvmlErrorString(result)); - } else { - gpus_slice[i].temp.push_back((long long)temp); - //? Reduce size if there are more values than needed for graph - while (cmp_greater(gpus_slice[i].temp.size(), 18)) gpus_slice[i].temp.pop_front(); - } + else gpus_slice[i].temp.push_back((long long)temp); } //? Memory info @@ -963,20 +967,19 @@ namespace Gpu { auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); gpus_slice[i].mem_used_percent.push_back(used_percent); - - //? Reduce size if there are more values than needed for graphs - while (cmp_greater(gpus_slice[i].mem_used_percent.size(), width/2)) gpus_slice[i].mem_used_percent.pop_front(); } //? PCIe link speeds - result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_TX_BYTES, &gpus_slice[i].pcie_tx); - if (result != NVML_SUCCESS) { + unsigned int tx,rx; + result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_TX_BYTES, &tx); + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get PCIe TX throughput: ") + nvmlErrorString(result)); - } - result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_RX_BYTES, &gpus_slice[i].pcie_rx); - if (result != NVML_SUCCESS) { + else gpus_slice[i].pcie_tx = (long long)tx; + + result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_RX_BYTES, &rx); + if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get PCIe RX throughput: ") + nvmlErrorString(result)); - } + else gpus_slice[i].pcie_rx = (long long)rx; //? TODO: Processes using GPU /*unsigned int proc_info_len; @@ -993,14 +996,172 @@ namespace Gpu { return true; } } - // TODO: AMD + + //? AMD + namespace Rsmi { + bool init() { + if (initialized) return false; + rsmi_status_t result; + + result = rsmi_init(0); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("Failed to initialize ROCm SMI, AMD GPUs will not be detected"); + + //? Device count + result = rsmi_num_monitor_devices(&device_count); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to fetch number of devices"); + + if (device_count > 0) { + gpus.resize(gpus.size() + device_count); + gpu_names.resize(gpus.size() + device_count); + + for (unsigned int i = 0; i < device_count; ++i) { + auto offset = Nvml::device_count + i; + + //? Device name + char name[NVML_DEVICE_NAME_BUFFER_SIZE]; // ROCm SMI does not provide a constant for this as far as I can tell, this should be good enough + result = rsmi_dev_name_get(i, name, NVML_DEVICE_NAME_BUFFER_SIZE); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get device name"); + else gpu_names[offset] = string(name); + + //? Power usage + uint64_t max_power; + result = rsmi_dev_power_cap_get(i, 0, &max_power); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get maximum GPU power draw, defaulting to 225W"); + else gpus[offset].pwr_max_usage = (long long)(max_power/1000); // RSMI reports power in microWatts + + //? Get temp_max + int64_t temp_max; + result = rsmi_dev_temp_metric_get(i, RSMI_TEMP_TYPE_EDGE, RSMI_TEMP_MAX, &temp_max); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get maximum GPU temperature, defaulting to 110"); + else gpus[offset].temp_max = (long long)temp_max; + } + initialized = true; + + return true; + } else {initialized = true; shutdown(); return false;} + } + + bool shutdown() { + if (!initialized) return false; + + if (rsmi_shut_down() == RSMI_STATUS_SUCCESS) + initialized = false; + else Logger::warning("Failed to shutdown ROCm SMI"); + + return true; + } + + bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count, offset by Nvml::device_count elements + if (!initialized) return false; + rsmi_status_t result; + + for (uint32_t i = 0; i < device_count; ++i) { + //? GPU utilization + uint32_t utilization; + result = rsmi_dev_busy_percent_get(i, &utilization); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get GPU utilization"); + else + gpus_slice[i].gpu_percent.push_back((long long)utilization); + + //? Memory utilization + result = rsmi_dev_memory_busy_percent_get(i, &utilization); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get VRAM utilization"); + else + gpus_slice[i].mem_utilization_percent.push_back((long long)utilization); + + //? Clock speeds + rsmi_frequencies_t frequencies; + result = rsmi_dev_gpu_clk_freq_get(i, RSMI_CLK_TYPE_SYS, &frequencies); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get GPU clock speed: "); + else gpus_slice[i].gpu_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz + + result = rsmi_dev_gpu_clk_freq_get(i, RSMI_CLK_TYPE_MEM, &frequencies); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get VRAM clock speed: "); + else gpus_slice[i].mem_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz + + //? Power usage & state + uint64_t power; + result = rsmi_dev_power_ave_get(i, 0, &power); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get GPU power usage"); + else + gpus_slice[i].pwr_percent.push_back(clamp((long long)round((double)gpus_slice[i].pwr_usage * 100.0 / (double)gpus_slice[i].pwr_max_usage), 0ll, 100ll)); + gpus_slice[i].pwr_state = 32; // NVML_PSTATE_UNKNOWN; won't display in GUI + + //? GPU temperature + if (Config::getB("check_temp")) { + int64_t temp; + result = rsmi_dev_temp_metric_get(i, RSMI_TEMP_TYPE_EDGE, RSMI_TEMP_CURRENT, &temp); + if (result != RSMI_STATUS_SUCCESS) + Logger::error("ROCm SMI: Failed to get GPU temperature"); + else gpus_slice[i].temp.push_back((long long)temp/1000); + } + + //? Memory info + uint64_t total, used; + result = rsmi_dev_memory_total_get(i, RSMI_MEM_TYPE_VRAM, &total); + if (result != RSMI_STATUS_SUCCESS) { + Logger::error("ROCm SMI: Failed to get total VRAM"); + } else { + gpus_slice[i].mem_total = total; + + result = rsmi_dev_memory_usage_get(i, RSMI_MEM_TYPE_VRAM, &used); + if (result != RSMI_STATUS_SUCCESS) { + Logger::error("ROCm SMI: Failed to get VRAM usage"); + } else { + gpus_slice[i].mem_used = used; + + auto used_percent = (long long)round((double)used * 100.0 / (double)total); + gpus_slice[i].mem_used_percent.push_back(used_percent); + } + } + + //? PCIe link speeds + uint64_t tx, rx; + result = rsmi_dev_pci_throughput_get(i, &tx, &rx, 0); + if (result != RSMI_STATUS_SUCCESS) { + Logger::error("ROCm SMI: Failed to get PCIe throughput"); + } else { + gpus_slice[i].pcie_tx = (long long)tx; + gpus_slice[i].pcie_rx = (long long)rx; + } + } + + return true; + } + } + // TODO: Intel //? Collect data from GPU-specific libraries auto collect(bool no_update) -> vector& { if (Runner::stopping or (no_update and not gpus.empty())) return gpus; - Nvml::collect(gpus.data()); // raw pointer to array data, size == Nvml::device_count, defined in Nvml::init() + //* Collect data + Nvml::collect(gpus.data()); // raw pointer to vector data, size == Nvml::device_count + Rsmi::collect(gpus.data() + Nvml::device_count); // size = Rsmi::device_count + + //* Trim vectors if there are more values than needed for graphs + for (auto& gpu : gpus) { + //? GPU & memory utilization + while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); + while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); + //? Power usage + while (cmp_greater(gpu.pwr_percent.size(), width)) gpu.pwr_percent.pop_front(); + //? Temperature + while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); + //? Memory usage + while (cmp_greater(gpu.mem_used_percent.size(), width/2)) gpu.mem_used_percent.pop_front(); + } return gpus; } From 22a463976d107a1e5849621e2a11f3e1071ed884 Mon Sep 17 00:00:00 2001 From: romner Date: Thu, 18 May 2023 16:07:05 +0200 Subject: [PATCH 098/209] Add GPU info to CPU panel --- src/btop.cpp | 25 +++++-- src/btop_config.cpp | 4 +- src/btop_draw.cpp | 134 ++++++++++++++++++++++++++++++------- src/btop_shared.hpp | 111 +++++++++++++++--------------- src/linux/btop_collect.cpp | 56 ++++++++++++---- 5 files changed, 228 insertions(+), 102 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index f081d5d..7966f39 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -499,6 +499,20 @@ namespace Runner { //* Run collection and draw functions for all boxes try { + //? GPU data collection + vector gpus; + if ( + v_contains(conf.boxes, "gpu") + or Config::getS("cpu_graph_lower") == "default" + or Config::getS("cpu_graph_lower").rfind("gpu-", 0) == 0 + or Config::getS("cpu_graph_upper").rfind("gpu-", 0) == 0 + or true + ) { + if (Global::debug) debug_timer("gpu", collect_begin); + gpus = Gpu::collect(conf.no_update); + } + auto& gpus_ref = gpus; + //? CPU if (v_contains(conf.boxes, "cpu")) { try { @@ -518,7 +532,7 @@ namespace Runner { if (Global::debug) debug_timer("cpu", draw_begin); //? Draw box - if (not pause_output) output += Cpu::draw(cpu, conf.force_redraw, conf.no_update); + if (not pause_output) output += Cpu::draw(cpu, gpus_ref, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("cpu", draw_done); } @@ -527,18 +541,15 @@ namespace Runner { } } - //? GPU + //? GPU // TODO detailed panel if (v_contains(conf.boxes, "gpu")) { try { - if (Global::debug) debug_timer("gpu", collect_begin); - - //? Start collect - auto gpus = Gpu::collect(conf.no_update); if (Global::debug) debug_timer("gpu", draw_begin); //? Draw box - if (not pause_output and not Gpu::gpu_names.empty()) output += Gpu::draw(gpus, conf.force_redraw, conf.no_update); + if (not pause_output and not Gpu::gpu_names.empty()) + output += Gpu::draw(gpus_ref, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("gpu", draw_done); } diff --git a/src/btop_config.cpp b/src/btop_config.cpp index 495af23..3890207 100644 --- a/src/btop_config.cpp +++ b/src/btop_config.cpp @@ -203,8 +203,8 @@ namespace Config { {"graph_symbol_net", "default"}, {"graph_symbol_proc", "default"}, {"proc_sorting", "cpu lazy"}, - {"cpu_graph_upper", "total"}, - {"cpu_graph_lower", "total"}, + {"cpu_graph_upper", "default"}, // set to "total" in btop_collect.cpp + {"cpu_graph_lower", "default"}, // set to "total" or "gpu-totals" in btop_collect.cpp {"cpu_sensor", "Auto"}, {"selected_battery", "Auto"}, {"cpu_core_map", ""}, diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 4baf9dd..9cb22df 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -495,17 +495,21 @@ namespace Cpu { int x = 1, y = 1, width = 20, height; int b_columns, b_column_size; int b_x, b_y, b_width, b_height; - int graph_up_height; long unsigned int lavg_str_len = 0; + int graph_up_height, graph_low_height; + int graph_up_width, graph_low_width; bool shown = true, redraw = true, mid_line = false; string box; - Draw::Graph graph_upper; - Draw::Graph graph_lower; + vector graphs_upper; + vector graphs_lower; Draw::Meter cpu_meter; + vector gpu_meters; vector core_graphs; vector temp_graphs; + vector gpu_temp_graphs; + vector gpu_mem_graphs; - string draw(const cpu_info& cpu, bool force_redraw, bool data_same) { + string draw(const cpu_info& cpu, const vector& gpus, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; bool show_temps = (Config::getB("check_temp") and got_sensors); @@ -531,8 +535,8 @@ namespace Cpu { //* Redraw elements not needed to be updated every cycle if (redraw) { mid_line = (not single_graph and graph_up_field != graph_lo_field); - graph_up_height = (single_graph ? height - 2 : ceil((double)(height - 2) / 2) - (mid_line and height % 2 != 0 ? 1 : 0)); - const int graph_low_height = height - 2 - graph_up_height - (mid_line ? 1 : 0); + graph_up_height = (single_graph ? height - 2 : ceil((double)(height - 2) / 2) - (mid_line and height % 2 != 0)); + graph_low_height = height - 2 - graph_up_height - mid_line; const int button_y = cpu_bottom ? y + height - 1 : y; out += box; @@ -549,17 +553,56 @@ namespace Cpu { Input::mouse_mappings["+"] = {button_y, x + width - 5, 1, 2}; //? Graphs & meters - graph_upper = Draw::Graph{x + width - b_width - 3, graph_up_height, "cpu", cpu.cpu_percent.at(graph_up_field), graph_symbol, false, true}; + const int graph_default_width = x + width - b_width - 3; + + auto init_graphs = [&](vector& graphs, const int graph_height, int& graph_width, const string& graph_field, bool invert) { + if (graph_field == "gpu-totals") { + graphs.resize(gpus.size()); + gpu_temp_graphs.resize(gpus.size()); + gpu_mem_graphs.resize(gpus.size()); + gpu_meters.resize(gpus.size()); + graph_width = graph_default_width/(int)gpus.size() - (int)gpus.size() + 1 + graph_default_width%gpus.size(); + for (unsigned long i = 0;;) { + auto& gpu = gpus[i]; auto& graph = graphs[i]; + + //? GPU graphs/meters + gpu_temp_graphs[i] = Draw::Graph{ 5, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23 }; + gpu_mem_graphs[i] = Draw::Graph{ 5, 1, "used", gpu.mem_used_percent, graph_symbol }; + gpu_meters[i] = Draw::Meter{ b_width - 12 - (int)floating_humanizer(gpu.mem_total, true).size() - (show_temps ? 24 : 12) - (int)to_string(i).size(), "cpu" }; + if (++i < gpus.size()) + graph = Draw::Graph{graph_width, graph_height, "cpu", gpu.gpu_percent, graph_symbol, invert, true}; + else { + graph = Draw::Graph{ + graph_width + graph_default_width%graph_width - (int)gpus.size() + 1, + graph_height, "cpu", gpu.gpu_percent, graph_symbol, invert, true + }; + break; + } + } + } else if (graph_field == "gpu-average") { + graphs.resize(1); + graph_width = graph_default_width; + graphs[0] = Draw::Graph{ graph_width, graph_height, "cpu", Gpu::average_gpu_percent, graph_symbol, invert, true }; + gpu_temp_graphs.resize(gpus.size()); + gpu_mem_graphs.resize(gpus.size()); + gpu_meters.resize(gpus.size()); + for (unsigned long i = 0; i < gpus.size(); ++i) { + gpu_temp_graphs[i] = Draw::Graph{ 5, 1, "temp", gpus[i].temp, graph_symbol, false, false, gpus[i].temp_max, -23 }; + gpu_mem_graphs[i] = Draw::Graph{ 5, 1, "used", gpus[i].mem_used_percent, graph_symbol }; + gpu_meters[i] = Draw::Meter{ b_width - 12 - (int)floating_humanizer(gpus[i].mem_total, true).size() - (show_temps ? 24 : 12) - (int)to_string(i).size(), "cpu" }; + } + } else { + graphs.resize(1); + graph_width = graph_default_width; + graphs[0] = Draw::Graph{ graph_width, graph_height, "cpu", cpu.cpu_percent.at(graph_field), graph_symbol, invert, true }; + } + }; + + init_graphs(graphs_upper, graph_up_height, graph_up_width, graph_up_field, false); + if (not single_graph) + init_graphs(graphs_lower, graph_low_height, graph_low_width, graph_lo_field, Config::getB("cpu_invert_lower")); + cpu_meter = Draw::Meter{b_width - (show_temps ? 23 - (b_column_size <= 1 and b_columns == 1 ? 6 : 0) : 11), "cpu"}; - if (not single_graph) { - graph_lower = Draw::Graph{ - x + width - b_width - 3, - graph_low_height, "cpu", - cpu.cpu_percent.at(graph_lo_field), - graph_symbol, - Config::getB("cpu_invert_lower"), true - }; - } if (mid_line) { out += Mv::to(y + graph_up_height + 1, x) + Fx::ub + Theme::c("cpu_box") + Symbols::div_left + Theme::c("div_line") @@ -627,10 +670,29 @@ namespace Cpu { } try { - //? Cpu graphs - out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(cpu.cpu_percent.at(graph_up_field), (data_same or redraw)); - if (not single_graph) - out += Mv::to( y + graph_up_height + 1 + (mid_line ? 1 : 0), x + 1) + graph_lower(cpu.cpu_percent.at(graph_lo_field), (data_same or redraw)); + //? Cpu/Gpu graphs + out += Fx::ub + Mv::to(y + 1, x + 1); + auto draw_graphs = [&](vector& graphs, const int graph_height, const int graph_width, const string& graph_field) { + if (graph_field == "gpu-totals") + for (unsigned long i = 0;;) { + out += graphs[i](gpus[i].gpu_percent, (data_same or redraw)); + if (gpus.size() > 1) { + auto i_str = to_string(i); + out += Mv::l(graph_width-1) + Mv::u(graph_height/2) + (graph_width > 5 ? "GPU " : "") + i_str + + Mv::d(graph_height/2) + Mv::r(graph_width - 1 - (graph_width > 5)*4 - i_str.size()); + } + if (++i < graphs.size()) + out += Theme::c("div_line") + (Symbols::v_line + Mv::l(1) + Mv::u(1))*graph_height + Mv::r(1) + Mv::d(1); + else break; + } + else out += graphs[0]((graph_field == "gpu-average" ? Gpu::average_gpu_percent : cpu.cpu_percent.at(graph_field)), (data_same or redraw)); + }; + + draw_graphs(graphs_upper, graph_up_height, graph_up_width, graph_up_field); + if (not single_graph) { + out += Mv::to(y + graph_up_height + 1 + mid_line, x + 1); + draw_graphs(graphs_lower, graph_low_height, graph_low_width, graph_lo_field); + } //? Uptime if (Config::getB("show_uptime")) { @@ -718,9 +780,26 @@ namespace Cpu { } else { lavg_str_len = lavg_str.length(); } - out += Mv::to(b_y + b_height - 2, b_x + cx + 1) + Theme::c("main_fg") + lavg_str; + out += Mv::to(b_y + b_height - 2 - gpus.size(), b_x + cx + 1) + Theme::c("main_fg") + lavg_str; } + //? Gpu brief info + if (graph_lo_field.rfind("gpu-", 0) or graph_up_field.rfind("gpu-", 0)) + for (unsigned long i = 0; i < gpus.size(); ++i) { + out += Mv::to(b_y + b_height - 1 - gpus.size() + i, b_x + 1) + + Theme::c("main_fg") + Fx::b + "GPU " + to_string(i) + ' ' + gpu_meters[i](gpus[i].gpu_percent.back()) + + Theme::g("cpu").at(gpus[i].gpu_percent.back()) + rjust(to_string(gpus[i].gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; + out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("used").at(gpus[i].mem_used_percent.back()) + + gpu_mem_graphs[i](gpus[i].mem_used_percent, data_same or redraw) + Theme::c("main_fg") + + rjust(floating_humanizer(gpus[i].mem_used, true), 5) + Theme::c("inactive_fg") + '/' + Theme::c("main_fg") + floating_humanizer(gpus[i].mem_total, true); + if (show_temps) { + const auto [temp, unit] = celsius_to(gpus[i].temp.back(), temp_scale); + out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpus[i].temp.back() * 100 / gpus[i].temp_max, 0ll, 100ll)) + + gpu_temp_graphs[i](gpus[i].temp, data_same or redraw) + + rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; + } + } + redraw = false; return out + Fx::reset; } @@ -1752,18 +1831,25 @@ namespace Draw { //* Calculate and draw cpu box outlines if (Cpu::shown) { using namespace Cpu; - bool show_temp = (Config::getB("check_temp") and got_sensors); + const bool gpus_shown_in_cpu_panel = ( + Config::getS("cpu_graph_lower") == "default" + or Config::getS("cpu_graph_lower").rfind("gpu-", 0) == 0 + or Config::getS("cpu_graph_upper").rfind("gpu-", 0) == 0 + ); + const int gpus_height_offset = Gpu::gpu_names.size()*gpus_shown_in_cpu_panel; + const bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); if (Gpu::shown and not (Mem::shown or Net::shown or Proc::shown)) { height = Term::height/2; } else { height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + Gpu::shown*5) / 100)); } + if (height <= Term::height-2) height += gpus_height_offset; x = 1; y = cpu_bottom ? Term::height - height + 1 : 1; - b_columns = max(1, (int)ceil((double)(Shared::coreCount + 1) / (height - 5))); + b_columns = max(1, (int)ceil((double)(Shared::coreCount + 1) / (height - gpus_height_offset*(height <= Term::height-2) - 5))); if (b_columns * (21 + 12 * show_temp) < width - (width / 3)) { b_column_size = 2; b_width = (21 + 12 * show_temp) * b_columns - (b_columns - 1); @@ -1781,7 +1867,7 @@ namespace Draw { } if (b_column_size == 0) b_width = (8 + 6 * show_temp) * b_columns + 1; - b_height = min(height - 2, (int)ceil((double)Shared::coreCount / b_columns) + 4); + b_height = min(height - 2, (int)ceil((double)Shared::coreCount / b_columns) + 4 + (int)gpus_height_offset - gpus_shown_in_cpu_panel); b_x = x + width - b_width - 1; b_y = y + ceil((double)(height - 2) / 2) - ceil((double)b_height / 2) + 1; diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 589536b..6b6d928 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -86,6 +86,61 @@ namespace Shared { } +namespace Gpu { + extern string box; + extern int x, y, width, height, min_width, min_height; + extern bool shown, redraw; + extern vector gpu_names; + extern deque average_gpu_percent; + + const array mem_names { "used"s, "free"s }; + + //* Container for process information // TODO + /*struct proc_info { + unsigned int pid; + unsigned long long mem; + };*/ + + //* Per-device container for GPU info + struct gpu_info { + deque gpu_percent = {0}; + unsigned int gpu_clock_speed = 0; // MHz + + deque pwr_percent = {0}; + long long pwr_usage = 0; // mW + long long pwr_max_usage = 255000; + long long pwr_state = 32; + + deque temp = {0}; + long long temp_max = 110; + + long long mem_total = 0; + long long mem_used = 0; + deque mem_used_percent = {0}; + deque mem_utilization_percent = {0}; // TODO: properly handle GPUs that can't report some stats + long long mem_clock_speed = 0; // MHz + + long long pcie_tx = 0; // KB/s + long long pcie_rx = 0; + + // vector graphics_processes = {}; // TODO + // vector compute_processes = {}; + }; + + namespace Nvml { + extern bool shutdown(); + } + namespace Rsmi { + extern bool shutdown(); + } + + //* Collect gpu stats and temperatures + auto collect(bool no_update = false) -> vector&; + + //* Draw contents of gpu box using as source + string draw(const vector& gpus, bool force_redraw, bool data_same); +} + namespace Cpu { extern string box; extern int x, y, width, height, min_width, min_height; @@ -119,7 +174,7 @@ namespace Cpu { auto collect(bool no_update = false) -> cpu_info&; //* Draw contents of cpu box using as source - string draw(const cpu_info& cpu, bool force_redraw = false, bool data_same = false); + string draw(const cpu_info& cpu, const vector& gpu, bool force_redraw = false, bool data_same = false); //* Parse /proc/cpu info for mapping of core ids auto get_core_mapping() -> unordered_flat_map; @@ -313,57 +368,3 @@ namespace Proc { int cur_depth, bool collapsed, const string& filter, bool found = false, bool no_update = false, bool should_filter = false); } - -namespace Gpu { - extern string box; - extern int x, y, width, height, min_width, min_height; - extern bool shown, redraw; - extern vector gpu_names; - - const array mem_names { "used"s, "free"s }; - - //* Container for process information // TODO - /*struct proc_info { - unsigned int pid; - unsigned long long mem; - };*/ - - //* Per-device container for GPU info - struct gpu_info { - deque gpu_percent = {0}; - unsigned int gpu_clock_speed = 0; // MHz - - deque pwr_percent = {0}; - long long pwr_usage = 0; // mW - long long pwr_max_usage = 255000; - long long pwr_state = 32; - - deque temp = {0}; - long long temp_max = 110; - - long long mem_total = 0; - long long mem_used = 0; - deque mem_used_percent = {0}; - deque mem_utilization_percent = {0}; // TODO: properly handle GPUs that can't report some stats - long long mem_clock_speed = 0; // MHz - - long long pcie_tx = 0; // KB/s - long long pcie_rx = 0; - - // vector graphics_processes = {}; // TODO - // vector compute_processes = {}; - }; - - namespace Nvml { - extern bool shutdown(); - } - namespace Rsmi { - extern bool shutdown(); - } - - //* Collect gpu stats and temperatures - auto collect(bool no_update = false) -> vector&; - - //* Draw contents of gpu box using as source - string draw(const vector& gpus, bool force_redraw, bool data_same); -} diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index bb47aeb..31d9438 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -94,6 +94,7 @@ namespace Cpu { namespace Gpu { vector gpus; vector gpu_names; + deque average_gpu_percent = {}; //? NVIDIA data collection namespace Nvml { @@ -172,13 +173,24 @@ namespace Shared { } Cpu::core_mapping = Cpu::get_core_mapping(); + //? Init for namespace Gpu + Gpu::Nvml::init(); + Gpu::Rsmi::init(); + if (not Gpu::gpu_names.empty()) { + Cpu::available_fields.push_back("gpu-totals"); + Cpu::available_fields.push_back("gpu-average"); + if (Config::strings.at("cpu_graph_lower") == "default") + Config::strings.at("cpu_graph_lower") = "gpu-totals"; + } + //? Init for namespace Mem Mem::old_uptime = system_uptime(); Mem::collect(); - //? Init for namespace Gpu - Gpu::Nvml::init(); - Gpu::Rsmi::init(); + if (Config::strings.at("cpu_graph_upper") == "default") + Config::strings.at("cpu_graph_upper") = "total"; + if (Config::strings.at("cpu_graph_lower") == "default") + Config::strings.at("cpu_graph_lower") = "total"; } } @@ -870,7 +882,13 @@ namespace Gpu { result = nvmlDeviceGetName(devices[i], name, NVML_DEVICE_NAME_BUFFER_SIZE); if (result != NVML_SUCCESS) Logger::error(std::string("NVML: Failed to get device name: ") + nvmlErrorString(result)); - else gpu_names[i] = string(name); + else { + gpu_names[i] = string(name); + for (const auto& brand : {"NVIDIA", "Nvidia", "AMD", "Amd", "Intel", "(R)", "(TM)"}) { + gpu_names[i] = s_replace(gpu_names[i], brand, ""); + } + gpu_names[i] = trim(gpu_names[i]); + } //? Power usage unsigned int max_power; @@ -1150,18 +1168,28 @@ namespace Gpu { Nvml::collect(gpus.data()); // raw pointer to vector data, size == Nvml::device_count Rsmi::collect(gpus.data() + Nvml::device_count); // size = Rsmi::device_count - //* Trim vectors if there are more values than needed for graphs + //* Calculate average usage + long long avg = 0; for (auto& gpu : gpus) { - //? GPU & memory utilization - while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); - while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); - //? Power usage - while (cmp_greater(gpu.pwr_percent.size(), width)) gpu.pwr_percent.pop_front(); - //? Temperature - while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); - //? Memory usage - while (cmp_greater(gpu.mem_used_percent.size(), width/2)) gpu.mem_used_percent.pop_front(); + avg += gpu.gpu_percent.back(); + + //* Trim vectors if there are more values than needed for graphs + if (width != 0) { + //? GPU & memory utilization + while (cmp_greater(gpu.gpu_percent.size(), width * 2)) gpu.gpu_percent.pop_front(); + while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); + //? Power usage + while (cmp_greater(gpu.pwr_percent.size(), width)) gpu.pwr_percent.pop_front(); + //? Temperature + while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); + //? Memory usage + while (cmp_greater(gpu.mem_used_percent.size(), width/2)) gpu.mem_used_percent.pop_front(); + } } + average_gpu_percent.push_back(avg / gpus.size()); + + if (width != 0) + while (cmp_greater(average_gpu_percent.size(), width * 2)) average_gpu_percent.pop_front(); return gpus; } From 01acfd603eda8b40829a6453d1fdb22f9e472238 Mon Sep 17 00:00:00 2001 From: romner-set Date: Fri, 19 May 2023 16:42:32 +0200 Subject: [PATCH 099/209] Bind GPU panel to 5,6,7,8,9,0 and fully implement multi-GPU support --- src/btop.cpp | 26 +++--- src/btop_config.cpp | 2 +- src/btop_config.hpp | 2 +- src/btop_draw.cpp | 191 +++++++++++++++++++++++++------------------- src/btop_input.cpp | 14 +++- src/btop_menu.cpp | 2 +- src/btop_shared.hpp | 11 ++- src/btop_tools.cpp | 11 ++- 8 files changed, 154 insertions(+), 105 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index 7966f39..9bf9cf4 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -501,13 +501,17 @@ namespace Runner { try { //? GPU data collection vector gpus; - if ( - v_contains(conf.boxes, "gpu") - or Config::getS("cpu_graph_lower") == "default" + bool gpu_in_cpu_panel = + Config::getS("cpu_graph_lower") == "default" or Config::getS("cpu_graph_lower").rfind("gpu-", 0) == 0 - or Config::getS("cpu_graph_upper").rfind("gpu-", 0) == 0 - or true - ) { + or Config::getS("cpu_graph_upper").rfind("gpu-", 0) == 0; + + vector gpu_panels = {}; + for (auto& box : conf.boxes) + if (box.rfind("gpu", 0) == 0) + gpu_panels.push_back(box.back()-'0'); + + if (gpu_in_cpu_panel or not gpu_panels.empty()) { if (Global::debug) debug_timer("gpu", collect_begin); gpus = Gpu::collect(conf.no_update); } @@ -541,15 +545,15 @@ namespace Runner { } } - //? GPU // TODO detailed panel - if (v_contains(conf.boxes, "gpu")) { + //? GPU + if (not gpu_panels.empty() and not gpus_ref.empty()) { try { - if (Global::debug) debug_timer("gpu", draw_begin); //? Draw box - if (not pause_output and not Gpu::gpu_names.empty()) - output += Gpu::draw(gpus_ref, conf.force_redraw, conf.no_update); + if (not pause_output) + for (unsigned long i = 0; i < gpu_panels.size(); ++i) + output += Gpu::draw(gpus_ref[gpu_panels[i]], i, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("gpu", draw_done); } diff --git a/src/btop_config.cpp b/src/btop_config.cpp index 3890207..4f7bb3e 100644 --- a/src/btop_config.cpp +++ b/src/btop_config.cpp @@ -316,7 +316,7 @@ namespace Config { validError = "Malformatted preset in config value presets!"; return false; } - if (not is_in(vals.at(0), "cpu", "mem", "net", "proc", "gpu")) { + if (not is_in(vals.at(0), "cpu", "mem", "net", "proc", "gpu0", "gpu1", "gpu2", "gpu3", "gpu4", "gpu5")) { validError = "Invalid box name in config value presets!"; return false; } diff --git a/src/btop_config.hpp b/src/btop_config.hpp index 46e6a4c..d9a9c3a 100644 --- a/src/btop_config.hpp +++ b/src/btop_config.hpp @@ -42,7 +42,7 @@ namespace Config { const vector valid_graph_symbols = { "braille", "block", "tty" }; const vector valid_graph_symbols_def = { "default", "braille", "block", "tty" }; - const vector valid_boxes = { "cpu", "mem", "net", "proc", "gpu" }; + const vector valid_boxes = { "cpu", "mem", "net", "proc", "gpu0", "gpu1", "gpu2", "gpu3", "gpu4", "gpu5" }; const vector temp_scales = { "celsius", "fahrenheit", "kelvin", "rankine" }; extern vector current_boxes; diff --git a/src/btop_draw.cpp b/src/btop_draw.cpp index 9cb22df..58e7c0d 100644 --- a/src/btop_draw.cpp +++ b/src/btop_draw.cpp @@ -755,6 +755,7 @@ namespace Cpu { } //? Load average + bool show_gpu = (graph_lo_field.rfind("gpu-", 0) == 0) or (graph_up_field.rfind("gpu-", 0) == 0); if (cy < b_height - 1 and cc <= b_columns) { string lavg_pre; int sep = 1; @@ -780,25 +781,29 @@ namespace Cpu { } else { lavg_str_len = lavg_str.length(); } - out += Mv::to(b_y + b_height - 2 - gpus.size(), b_x + cx + 1) + Theme::c("main_fg") + lavg_str; + out += Mv::to(b_y + b_height - 2 - show_gpu*(gpus.size() - Gpu::shown), b_x + cx + 1) + Theme::c("main_fg") + lavg_str; } //? Gpu brief info - if (graph_lo_field.rfind("gpu-", 0) or graph_up_field.rfind("gpu-", 0)) + if (show_gpu) { + auto shown_panels_count = 0u; for (unsigned long i = 0; i < gpus.size(); ++i) { - out += Mv::to(b_y + b_height - 1 - gpus.size() + i, b_x + 1) - + Theme::c("main_fg") + Fx::b + "GPU " + to_string(i) + ' ' + gpu_meters[i](gpus[i].gpu_percent.back()) - + Theme::g("cpu").at(gpus[i].gpu_percent.back()) + rjust(to_string(gpus[i].gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; - out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("used").at(gpus[i].mem_used_percent.back()) - + gpu_mem_graphs[i](gpus[i].mem_used_percent, data_same or redraw) + Theme::c("main_fg") - + rjust(floating_humanizer(gpus[i].mem_used, true), 5) + Theme::c("inactive_fg") + '/' + Theme::c("main_fg") + floating_humanizer(gpus[i].mem_total, true); - if (show_temps) { - const auto [temp, unit] = celsius_to(gpus[i].temp.back(), temp_scale); - out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpus[i].temp.back() * 100 / gpus[i].temp_max, 0ll, 100ll)) - + gpu_temp_graphs[i](gpus[i].temp, data_same or redraw) - + rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; + if (not v_contains(Gpu::shown_panels, i)) { + out += Mv::to(b_y + b_height - 1 - gpus.size() + ++shown_panels_count - (Gpu::shown == 0), b_x + 1) + + Theme::c("main_fg") + Fx::b + "GPU " + to_string(i) + ' ' + gpu_meters[i](gpus[i].gpu_percent.back()) + + Theme::g("cpu").at(gpus[i].gpu_percent.back()) + rjust(to_string(gpus[i].gpu_percent.back()), 4) + Theme::c("main_fg") + '%'; + out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("used").at(gpus[i].mem_used_percent.back()) + + gpu_mem_graphs[i](gpus[i].mem_used_percent, data_same or redraw) + Theme::c("main_fg") + + rjust(floating_humanizer(gpus[i].mem_used, true), 5) + Theme::c("inactive_fg") + '/' + Theme::c("main_fg") + floating_humanizer(gpus[i].mem_total, true); + if (show_temps) { + const auto [temp, unit] = celsius_to(gpus[i].temp.back(), temp_scale); + out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpus[i].temp.back() * 100 / gpus[i].temp_max, 0ll, 100ll)) + + gpu_temp_graphs[i](gpus[i].temp, data_same or redraw) + + rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; + } } } + } redraw = false; return out + Fx::reset; @@ -809,24 +814,38 @@ namespace Cpu { namespace Gpu { int width_p = 100, height_p = 32; int min_width = 41, min_height = 9; - int x = 1, y = 1, width = 41, height; - int b_columns, b_column_size; - int b_x, b_y, b_width, b_height; - int bproc_x, bproc_y, bproc_width, bproc_height; - bool shown = true, redraw = true, mid_line = false; + int width = 41, height; + vector x_vec = {}, y_vec = {}; + int b_width, b_height; + vector b_x_vec = {}, b_y_vec = {}; + vector redraw = {}, mid_line = {}; + int shown = 0; + vector shown_panels = {}; int graph_up_height; - Draw::Graph graph_upper; - Draw::Graph graph_lower; - Draw::Graph temp_graph; - Draw::Graph mem_used_graph; - Draw::Graph mem_util_graph; - Draw::Meter gpu_meter; - Draw::Meter pwr_meter; - string box; + vector graph_upper_vec = {}, graph_lower_vec = {}; + vector temp_graph_vec = {}; + vector mem_used_graph_vec = {}, mem_util_graph_vec = {}; + vector gpu_meter_vec = {}; + vector pwr_meter_vec = {}; + vector box = {}; - string draw(const vector& gpus, bool force_redraw, bool data_same) { + string draw(const gpu_info& gpu, unsigned long index, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; - if (force_redraw) redraw = true; + + auto& b_x = b_x_vec[index]; + auto& b_y = b_y_vec[index]; + auto& x = x_vec[index]; + auto& y = y_vec[index]; + + auto& graph_upper = graph_upper_vec[index]; + auto& graph_lower = graph_lower_vec[index]; + auto& temp_graph = temp_graph_vec[index]; + auto& mem_used_graph = mem_used_graph_vec[index]; + auto& mem_util_graph = mem_util_graph_vec[index]; + auto& gpu_meter = gpu_meter_vec[index]; + auto& pwr_meter = pwr_meter_vec[index]; + + if (force_redraw) redraw[index] = true; bool show_temps = (Config::getB("check_temp")); auto tty_mode = Config::getB("tty_mode"); auto& temp_scale = Config::getS("temp_scale"); @@ -836,13 +855,11 @@ namespace Gpu { string out; out.reserve(width * height); - auto gpu = gpus[0]; // TODO: multi-gpu support - //* Redraw elements not needed to be updated every cycle - if (redraw) { + if (redraw[index]) { graph_up_height = single_graph ? height - 2 : ceil((double)(height - 2) / 2); - const int graph_low_height = height - 2 - graph_up_height - (mid_line ? 1 : 0); - out += box; + const int graph_low_height = height - 2 - graph_up_height - (mid_line[index] ? 1 : 0); + out += box[index]; graph_upper = Draw::Graph{x + width - b_width - 3, graph_up_height, "cpu", gpu.gpu_percent, graph_symbol, false, true}; // TODO cpu -> gpu if (not single_graph) { @@ -868,9 +885,9 @@ namespace Gpu { //* General GPU info //? Gpu graph, clock speed & meter - out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw)); + out += Fx::ub + Mv::to(y + 1, x + 1) + graph_upper(gpu.gpu_percent, (data_same or redraw[index])); if (not single_graph) - out += Mv::to(y + graph_up_height + 1 + mid_line, x + 1) + graph_lower(gpu.gpu_percent, (data_same or redraw)); + out += Mv::to(y + graph_up_height + 1 + mid_line[index], x + 1) + graph_lower(gpu.gpu_percent, (data_same or redraw[index])); if (Config::getB("show_cpu_freq")) { // TODO show_gpu_freq string clock_speed_string = to_string(gpu.gpu_clock_speed); @@ -885,7 +902,7 @@ namespace Gpu { if (show_temps) { const auto [temp, unit] = celsius_to(gpu.temp.back(), temp_scale); out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)) - + temp_graph(gpu.temp, data_same or redraw); + + temp_graph(gpu.temp, data_same or redraw[index]); out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; } out += Theme::c("div_line") + Symbols::v_line; @@ -915,8 +932,8 @@ namespace Gpu { out += Mv::to(b_y + 4, b_x + 2) + Theme::c("main_fg") + Fx::b + "Total:" + rjust(floating_humanizer(gpu.mem_total), b_width/2-9) + Fx::ub; //? Memory usage graphs & percentage - out += Mv::to(b_y+6, b_x+1) + Theme::c("inactive_fg") + mem_util_graph(gpu.mem_utilization_percent, (data_same or redraw)) - + Mv::u(3) + Mv::r(1) + mem_used_graph(gpu.mem_used_percent, (data_same or redraw)); + out += Mv::to(b_y+6, b_x+1) + Theme::c("inactive_fg") + mem_util_graph(gpu.mem_utilization_percent, (data_same or redraw[index])) + + Mv::u(3) + Mv::r(1) + mem_used_graph(gpu.mem_used_percent, (data_same or redraw[index])); out += Mv::to(b_y+6, b_x+1) + rjust(to_string(gpu.mem_utilization_percent.back()), 3) + '%' + Mv::u(2) + Mv::r(b_width/2-3) + rjust(to_string(gpu.mem_used_percent.back()), 3) + '%'; //? Processes section header @@ -932,13 +949,7 @@ namespace Gpu { + Symbols::title_left_down + Theme::c("title") + Fx::b + "RX:" + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*(b_width/2+b_width%2-9-rx_string.size()) + Symbols::title_left_down + Theme::c("title") + Fx::b + rx_string + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::round_right_down; - //* GPU graphics process list - //! TODO - - //* GPU compute process list - //! TODO - - redraw = false; + redraw[index] = false; return out + Fx::reset; } } @@ -1816,14 +1827,27 @@ namespace Draw { Input::mouse_mappings.clear(); - Cpu::x = Gpu::x = Mem::x = Net::x = Proc::x = 1; - Cpu::y = Gpu::y = Mem::y = Net::y = Proc::y = 1; + Cpu::x = Mem::x = Net::x = Proc::x = 1; + Cpu::y = Mem::y = Net::y = Proc::y = 1; Cpu::width = Gpu::width = Mem::width = Net::width = Proc::width = 0; - Cpu::height = Gpu::height = Mem::height = Net::height = Proc::height = 0; - Cpu::redraw = Gpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; + Cpu::height = Mem::height = Net::height = Proc::height = 0; + Cpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; Cpu::shown = s_contains(boxes, "cpu"); - Gpu::shown = s_contains(boxes, "gpu") and not Gpu::gpu_names.empty(); + Gpu::shown_panels.clear(); + if (not Gpu::gpu_names.empty()) { + std::istringstream iss(boxes, std::istringstream::in); + string current; + while (iss >> current) + if ( current == "gpu0" + or current == "gpu1" + or current == "gpu2" + or current == "gpu3" + or current == "gpu4" + or current == "gpu5" + ) Gpu::shown_panels.push_back(current.back()-'0'); + } + Gpu::shown = Gpu::shown_panels.size(); Mem::shown = s_contains(boxes, "mem"); Net::shown = s_contains(boxes, "net"); Proc::shown = s_contains(boxes, "proc"); @@ -1835,14 +1859,14 @@ namespace Draw { Config::getS("cpu_graph_lower") == "default" or Config::getS("cpu_graph_lower").rfind("gpu-", 0) == 0 or Config::getS("cpu_graph_upper").rfind("gpu-", 0) == 0 - ); - const int gpus_height_offset = Gpu::gpu_names.size()*gpus_shown_in_cpu_panel; + ) and Gpu::gpu_names.size() != (unsigned long)Gpu::shown; + const int gpus_height_offset = (Gpu::gpu_names.size() - Gpu::shown)*gpus_shown_in_cpu_panel; const bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); - if (Gpu::shown and not (Mem::shown or Net::shown or Proc::shown)) { + if (Gpu::shown != 0 and not (Mem::shown or Net::shown or Proc::shown)) { height = Term::height/2; } else { - height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + Gpu::shown*5) / 100)); + height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + (Gpu::shown != 0)*5) / 100)); } if (height <= Term::height-2) height += gpus_height_offset; @@ -1880,31 +1904,36 @@ namespace Draw { } //* Calculate and draw gpu box outlines - if (Gpu::shown) { + if (Gpu::shown != 0) { using namespace Gpu; - width = Term::width; - height = max(Gpu::min_height, Cpu::shown ? Cpu::height : (int)ceil((double)Term::height * (trim(boxes) == "gpu" ? 100 : height_p) / 100)); - height += height+Cpu::height == Term::height-1; - x = 1; y = 1 + Cpu::shown*Cpu::height; - box = createBox(x, y, width, height, Theme::c("cpu_box"), true, "gpu", "", 5); // TODO gpu_box + x_vec.resize(shown); y_vec.resize(shown); + b_x_vec.resize(shown); b_y_vec.resize(shown); + box.resize(shown); + graph_upper_vec.resize(shown); graph_lower_vec.resize(shown); + temp_graph_vec.resize(shown); + mem_used_graph_vec.resize(shown); mem_util_graph_vec.resize(shown); + gpu_meter_vec.resize(shown); + pwr_meter_vec.resize(shown); + redraw.resize(shown); + mid_line.resize(shown); + for (auto i = 0; i < shown; ++i) { + redraw[i] = true; - b_height = 9; - b_width = clamp(width/2, min_width, b_height*6); + width = Term::width; + height = max(min_height, Cpu::shown ? Cpu::height : (int)ceil((double)Term::height * height_p / 100)); + height += (height+Cpu::height == Term::height-1); + x_vec[i] = 1; y_vec[i] = 1 + i*height + (not Config::getB("cpu_bottom"))*Cpu::shown*Cpu::height; + box[i] = createBox(x_vec[i], y_vec[i], width, height, Theme::c("cpu_box"), true, std::string("gpu") + (char)(shown_panels[i]+'0'), "", (shown_panels[i]+5)%10); // TODO gpu_box - // bproc_width = b_width; - // bproc_height = height-11; + b_height = 9; + b_width = clamp(width/2, min_width, b_height*6); - //? Main statistics box - b_x = x + width - b_width - 1; - b_y = y + ceil((double)(height - 2) / 2) - ceil((double)(b_height/*+bproc_height*/) / 2) + 1; + //? Main statistics box + b_x_vec[i] = x_vec[i] + width - b_width - 1; + b_y_vec[i] = y_vec[i] + ceil((double)(height - 2) / 2) - ceil((double)(b_height) / 2) + 1; - box += createBox(b_x, b_y, b_width, b_height, "", false, gpu_names[0]); - - //? TODO: Processes box - /*bproc_x = x + width - bproc_width - 1; - bproc_y = b_y + b_height; - - box += createBox(bproc_x, bproc_y, bproc_width, bproc_height, "", false, "gpu-proc");*/ + box[i] += createBox(b_x_vec[i], b_y_vec[i], b_width, b_height, "", false, gpu_names[shown_panels[i]].substr(0, b_width-5)); + } } //* Calculate and draw mem box outlines @@ -1915,12 +1944,12 @@ namespace Draw { auto mem_graphs = Config::getB("mem_graphs"); width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); - height = ceil((double)Term::height * (100 - Net::height_p * Net::shown*4 / ((Gpu::shown and Cpu::shown) + 4)) / 100) - Cpu::height - Gpu::height; + height = ceil((double)Term::height * (100 - Net::height_p * Net::shown*4 / ((Gpu::shown != 0 and Cpu::shown) + 4)) / 100) - Cpu::height - Gpu::height*Gpu::shown; x = (proc_left and Proc::shown) ? Term::width - width + 1: 1; if (mem_below_net and Net::shown) - y = Term::height - height + 1 - (cpu_bottom ? Cpu::height + Gpu::height : 0); + y = Term::height - height + 1 - (cpu_bottom ? Cpu::height + Gpu::height*Gpu::shown : 0); else - y = cpu_bottom ? 1 : Cpu::height + Gpu::height + 1; + y = cpu_bottom ? 1 : Cpu::height + Gpu::height*Gpu::shown + 1; if (show_disks) { mem_width = ceil((double)(width - 3) / 2); @@ -1969,10 +1998,10 @@ namespace Draw { if (Net::shown) { using namespace Net; width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); - height = Term::height - Cpu::height - Gpu::height - Mem::height; + height = Term::height - Cpu::height - Gpu::height*Gpu::shown - Mem::height; x = (proc_left and Proc::shown) ? Term::width - width + 1 : 1; if (mem_below_net and Mem::shown) - y = cpu_bottom ? 1 : Cpu::height + Gpu::height + 1; + y = cpu_bottom ? 1 : Cpu::height + Gpu::height*Gpu::shown + 1; else y = Term::height - height + 1 - (cpu_bottom ? Cpu::height : 0); @@ -1991,9 +2020,9 @@ namespace Draw { if (Proc::shown) { using namespace Proc; width = Term::width - (Mem::shown ? Mem::width : (Net::shown ? Net::width : 0)); - height = Term::height - Cpu::height - Gpu::height; + height = Term::height - Cpu::height - Gpu::height*Gpu::shown; x = proc_left ? 1 : Term::width - width + 1; - y = (cpu_bottom and Cpu::shown) ? 1 : Cpu::height + Gpu::height + 1; + y = (cpu_bottom and Cpu::shown) ? 1 : Cpu::height + Gpu::height*Gpu::shown + 1; select_max = height - 3; box = createBox(x, y, width, height, Theme::c("proc_box"), true, "proc", "", 4); } diff --git a/src/btop_input.cpp b/src/btop_input.cpp index 9113a42..f27cea9 100644 --- a/src/btop_input.cpp +++ b/src/btop_input.cpp @@ -260,15 +260,25 @@ namespace Input { Menu::show(Menu::Menus::Options); return; } - else if (is_in(key, "1", "2", "3", "4", "5")) { + else if (is_in(key, "1", "2", "3", "4")) { atomic_wait(Runner::active); Config::current_preset = -1; - static const array boxes = {"cpu", "mem", "net", "proc", "gpu"}; + static const array boxes = {"cpu", "mem", "net", "proc"}; Config::toggle_box(boxes.at(std::stoi(key) - 1)); Draw::calcSizes(); Runner::run("all", false, true); return; } + else if (is_in(key, "5", "6", "7", "8", "9", "0")) { + atomic_wait(Runner::active); + Config::current_preset = -1; + auto key_i = std::stoi(key); + if (key_i-4u >= Gpu::gpu_names.size()) return; + Config::toggle_box(std::string("gpu") + (char)((key_i == 0 ? 10 : (key_i-5)) + '0')); + Draw::calcSizes(); + Runner::run("all", false, true); + return; + } else if (is_in(key, "p", "P") and Config::preset_list.size() > 1) { if (key == "p") { if (++Config::current_preset >= (int)Config::preset_list.size()) Config::current_preset = 0; diff --git a/src/btop_menu.cpp b/src/btop_menu.cpp index fa0028b..343fbca 100644 --- a/src/btop_menu.cpp +++ b/src/btop_menu.cpp @@ -1264,7 +1264,7 @@ namespace Menu { //? Category buttons out += Mv::to(y+7, x+4); - for (int i = 0; const auto& m : {"general", "cpu", "mem", "net", "proc", "gpu"}) { + for (int i = 0; const auto& m : {"general", "cpu", "mem", "net", "proc"}) { out += Fx::b + (i == selected_cat ? Theme::c("hi_fg") + '[' + Theme::c("title") + m + Theme::c("hi_fg") + ']' : Theme::c("hi_fg") + to_string(i + 1) + Theme::c("title") + m + ' ') diff --git a/src/btop_shared.hpp b/src/btop_shared.hpp index 6b6d928..13cd9f6 100644 --- a/src/btop_shared.hpp +++ b/src/btop_shared.hpp @@ -87,9 +87,12 @@ namespace Shared { namespace Gpu { - extern string box; - extern int x, y, width, height, min_width, min_height; - extern bool shown, redraw; + extern vector box; + extern int width, height, min_width, min_height; + extern vector x_vec, y_vec; + extern vector redraw; + extern int shown; + extern vector shown_panels; extern vector gpu_names; extern deque average_gpu_percent; @@ -138,7 +141,7 @@ namespace Gpu { auto collect(bool no_update = false) -> vector&; //* Draw contents of gpu box using as source - string draw(const vector& gpus, bool force_redraw, bool data_same); + string draw(const gpu_info& gpu, unsigned long index, bool force_redraw, bool data_same); } namespace Cpu { diff --git a/src/btop_tools.cpp b/src/btop_tools.cpp index 9f61ff9..f3fc37d 100644 --- a/src/btop_tools.cpp +++ b/src/btop_tools.cpp @@ -103,18 +103,21 @@ namespace Term { bool mem = boxes.find("mem") != string::npos; bool net = boxes.find("net") != string::npos; bool proc = boxes.find("proc") != string::npos; - bool gpu = boxes.find("gpu") != string::npos and not Gpu::gpu_names.empty(); - int width = 0; + bool gpu = 0; + if (not Gpu::gpu_names.empty()) + for (char i = '0'; i <= '5'; ++i) + gpu += (boxes.find(std::string("gpu") + i) != string::npos); + int width = 0; if (mem) width = Mem::min_width; else if (net) width = Mem::min_width; width += (proc ? Proc::min_width : 0); if (cpu and width < Cpu::min_width) width = Cpu::min_width; - if (gpu and width < Gpu::min_width) width = Gpu::min_width; + if (gpu != 0 and width < Gpu::min_width) width = Gpu::min_width; int height = (cpu ? Cpu::min_height : 0); if (proc) height += Proc::min_height; else height += (mem ? Mem::min_height : 0) + (net ? Net::min_height : 0); - if (gpu) height += Gpu::min_height; + if (gpu != 0) height += Gpu::min_height*gpu; return { width, height }; } From 8bae1ec092814368b04fb49827c7b89c327c62d6 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sat, 20 May 2023 00:13:00 +0200 Subject: [PATCH 100/209] Fixed debug timer for gpu --- src/btop.cpp | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/btop.cpp b/src/btop.cpp index 9bf9cf4..016f562 100644 --- a/src/btop.cpp +++ b/src/btop.cpp @@ -394,7 +394,9 @@ namespace Runner { enum debug_actions { collect_begin, + collect_done, draw_begin, + draw_begin_only, draw_done }; @@ -430,6 +432,13 @@ namespace Runner { case collect_begin: debug_times[name].at(collect) = time_micros(); return; + case collect_done: + debug_times[name].at(collect) = time_micros() - debug_times[name].at(collect); + debug_times["total"].at(collect) += debug_times[name].at(collect); + return; + case draw_begin_only: + debug_times[name].at(draw) = time_micros(); + return; case draw_begin: debug_times[name].at(draw) = time_micros(); debug_times[name].at(collect) = debug_times[name].at(draw) - debug_times[name].at(collect); @@ -489,8 +498,6 @@ namespace Runner { if (debug_bg.empty() or redraw) Runner::debug_bg = Draw::createBox(2, 2, 33, 8, "", true, "μs"); - - debug_times.clear(); debug_times["total"] = {0, 0}; } @@ -514,6 +521,7 @@ namespace Runner { if (gpu_in_cpu_panel or not gpu_panels.empty()) { if (Global::debug) debug_timer("gpu", collect_begin); gpus = Gpu::collect(conf.no_update); + if (Global::debug) debug_timer("gpu", collect_done); } auto& gpus_ref = gpus; @@ -548,7 +556,7 @@ namespace Runner { //? GPU if (not gpu_panels.empty() and not gpus_ref.empty()) { try { - if (Global::debug) debug_timer("gpu", draw_begin); + if (Global::debug) debug_timer("gpu", draw_begin_only); //? Draw box if (not pause_output) From 8c710a2b687954bd66f07b02265da420bf645379 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sat, 20 May 2023 01:41:04 +0200 Subject: [PATCH 101/209] Makefile auto detection and initial logic for excluding gpu code when libs are missing --- Makefile | 16 ++++++++++++++ src/linux/btop_collect.cpp | 45 ++++++++++++++++++++++++++++++++------ 2 files changed, 54 insertions(+), 7 deletions(-) diff --git a/Makefile b/Makefile index a64a2e5..3d41dda 100644 --- a/Makefile +++ b/Makefile @@ -119,6 +119,22 @@ ifeq ($(PLATFORM_LC),linux) PLATFORM_DIR := linux THREADS := $(shell getconf _NPROCESSORS_ONLN 2>/dev/null || echo 1) SU_GROUP := root + ifneq ($(NO_GPU),true) + ifeq ($(shell find /usr/local/cuda/include/ -type f -name nvml.h >/dev/null 2>&1; echo $$?),0) + GPUCXXFLAGS := -I/usr/local/cuda/include + GPULDFLAGS := -L/usr/local/cuda/lib -lnvidia-ml + override ADDFLAGS += -DGPU_NVIDIA + else ifeq ($(shell find /opt/cuda/include/ -type f -name nvml.h >/dev/null 2>&1; echo $$?),0) + GPUCXXFLAGS := -I/opt/cuda/include + GPULDFLAGS := -L/opt/cuda/lib -lnvidia-ml + override ADDFLAGS += -DGPU_NVIDIA + endif + ifeq ($(shell find /opt/rocm/include/rocm_smi/ -type f -name rocm_smi.h >/dev/null 2>&1; echo $$?),0) + GPUCXXFLAGS += -I/opt/rocm/include + GPULDFLAGS += -L/opt/rocm/lib -lrocm_smi64 + override ADDFLAGS += -DGPU_AMD + endif + endif else ifeq ($(PLATFORM_LC),freebsd) PLATFORM_DIR := freebsd THREADS := $(shell getconf NPROCESSORS_ONLN 2>/dev/null || echo 1) diff --git a/src/linux/btop_collect.cpp b/src/linux/btop_collect.cpp index 31d9438..935f970 100644 --- a/src/linux/btop_collect.cpp +++ b/src/linux/btop_collect.cpp @@ -28,8 +28,12 @@ tab-size = 4 #include #include #include // for inet_ntop() -#include -#include +#if defined(GPU_NVIDIA) + #include +#endif +#if defined(GPU_AMD) + #include +#endif #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) @@ -101,7 +105,9 @@ namespace Gpu { bool initialized = false; bool init(); bool shutdown(); + #if defined(GPU_NVIDIA) vector devices; + #endif unsigned int device_count = 0; } @@ -187,10 +193,12 @@ namespace Shared { Mem::old_uptime = system_uptime(); Mem::collect(); - if (Config::strings.at("cpu_graph_upper") == "default") + if (Config::strings.at("cpu_graph_upper") == "default" or not v_contains(Cpu::available_fields, Config::strings.at("cpu_graph_upper"))) Config::strings.at("cpu_graph_upper") = "total"; - if (Config::strings.at("cpu_graph_lower") == "default") + if (Config::strings.at("cpu_graph_lower") == "default" or not v_contains(Cpu::available_fields, Config::strings.at("cpu_graph_lower"))) Config::strings.at("cpu_graph_lower") = "total"; + + Logger::debug("Shared::init() : Initialized."); } } @@ -850,7 +858,7 @@ namespace Gpu { namespace Nvml { bool init() { if (initialized) return false; - + #if defined(GPU_NVIDIA) nvmlReturn_t result = nvmlInit(); if (result != NVML_SUCCESS) { Logger::warning(std::string("Failed to initialize NVML, NVIDIA GPUs will not be detected: ") + nvmlErrorString(result)); @@ -908,21 +916,28 @@ namespace Gpu { return true; } else {initialized = true; shutdown(); return false;} + #else + return false; + #endif } bool shutdown() { if (!initialized) return false; - + #if defined(GPU_NVIDIA) nvmlReturn_t result = nvmlShutdown(); if (NVML_SUCCESS == result) initialized = false; else Logger::warning(std::string("Failed to shutdown NVML: ") + nvmlErrorString(result)); return !initialized; + #else + return false; + #endif } bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count if (!initialized) return false; + #if defined(GPU_NVIDIA) nvmlReturn_t result; for (unsigned int i = 0; i < device_count; ++i) { @@ -1012,6 +1027,10 @@ namespace Gpu { } return true; + #else + (void)gpus_slice; + return false; + #endif } } @@ -1019,6 +1038,7 @@ namespace Gpu { namespace Rsmi { bool init() { if (initialized) return false; + #if defined(GPU_AMD) rsmi_status_t result; result = rsmi_init(0); @@ -1062,20 +1082,27 @@ namespace Gpu { return true; } else {initialized = true; shutdown(); return false;} + #else + return false; + #endif } bool shutdown() { if (!initialized) return false; - + #if defined(GPU_AMD) if (rsmi_shut_down() == RSMI_STATUS_SUCCESS) initialized = false; else Logger::warning("Failed to shutdown ROCm SMI"); return true; + #else + return false; + #endif } bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count, offset by Nvml::device_count elements if (!initialized) return false; + #if defined(GPU_AMD) rsmi_status_t result; for (uint32_t i = 0; i < device_count; ++i) { @@ -1155,6 +1182,10 @@ namespace Gpu { } return true; + #else + (void)gpus_slice; + return false; + #endif } } From 21b85f8913f31aed4c6c6981968cd590303a62b0 Mon Sep 17 00:00:00 2001 From: aristocratos Date: Sat, 20 May 2023 14:52:50 +0200 Subject: [PATCH 102/209] btop.cpp -> fmt --- include/fmt/args.h | 234 ++ include/fmt/chrono.h | 2268 ++++++++++++++++++ include/fmt/color.h | 633 +++++ include/fmt/compile.h | 607 +++++ include/fmt/core.h | 2920 +++++++++++++++++++++++ include/fmt/format-inl.h | 1662 ++++++++++++++ include/fmt/format.h | 4725 ++++++++++++++++++++++++++++++++++++++ include/fmt/os.h | 451 ++++ include/fmt/ostream.h | 209 ++ include/fmt/printf.h | 667 ++++++ include/fmt/ranges.h | 732 ++++++ include/fmt/std.h | 349 +++ include/fmt/xchar.h | 258 +++ src/btop.cpp | 117 +- src/btop_tools.cpp | 12 +- src/btop_tools.hpp | 8 +- 16 files changed, 15804 insertions(+), 48 deletions(-) create mode 100644 include/fmt/args.h create mode 100644 include/fmt/chrono.h create mode 100644 include/fmt/color.h create mode 100644 include/fmt/compile.h create mode 100644 include/fmt/core.h create mode 100644 include/fmt/format-inl.h create mode 100644 include/fmt/format.h create mode 100644 include/fmt/os.h create mode 100644 include/fmt/ostream.h create mode 100644 include/fmt/printf.h create mode 100644 include/fmt/ranges.h create mode 100644 include/fmt/std.h create mode 100644 include/fmt/xchar.h diff --git a/include/fmt/args.h b/include/fmt/args.h new file mode 100644 index 0000000..a3966d1 --- /dev/null +++ b/include/fmt/args.h @@ -0,0 +1,234 @@ +// Formatting library for C++ - dynamic format arguments +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_ARGS_H_ +#define FMT_ARGS_H_ + +#include // std::reference_wrapper +#include // std::unique_ptr +#include + +#include "core.h" + +FMT_BEGIN_NAMESPACE + +namespace detail { + +template struct is_reference_wrapper : std::false_type {}; +template +struct is_reference_wrapper> : std::true_type {}; + +template const T& unwrap(const T& v) { return v; } +template const T& unwrap(const std::reference_wrapper& v) { + return static_cast(v); +} + +class dynamic_arg_list { + // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for + // templates it doesn't complain about inability to deduce single translation + // unit for placing vtable. So storage_node_base is made a fake template. + template struct node { + virtual ~node() = default; + std::unique_ptr> next; + }; + + template struct typed_node : node<> { + T value; + + template + FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} + + template + FMT_CONSTEXPR typed_node(const basic_string_view& arg) + : value(arg.data(), arg.size()) {} + }; + + std::unique_ptr> head_; + + public: + template const T& push(const Arg& arg) { + auto new_node = std::unique_ptr>(new typed_node(arg)); + auto& value = new_node->value; + new_node->next = std::move(head_); + head_ = std::move(new_node); + return value; + } +}; +} // namespace detail + +/** + \rst + A dynamic version of `fmt::format_arg_store`. + It's equipped with a storage to potentially temporary objects which lifetimes + could be shorter than the format arguments object. + + It can be implicitly converted into `~fmt::basic_format_args` for passing + into type-erased formatting functions such as `~fmt::vformat`. + \endrst + */ +template +class dynamic_format_arg_store +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 + // Workaround a GCC template argument substitution bug. + : public basic_format_args +#endif +{ + private: + using char_type = typename Context::char_type; + + template struct need_copy { + static constexpr detail::type mapped_type = + detail::mapped_type_constant::value; + + enum { + value = !(detail::is_reference_wrapper::value || + std::is_same>::value || + std::is_same>::value || + (mapped_type != detail::type::cstring_type && + mapped_type != detail::type::string_type && + mapped_type != detail::type::custom_type)) + }; + }; + + template + using stored_type = conditional_t< + std::is_convertible>::value && + !detail::is_reference_wrapper::value, + std::basic_string, T>; + + // Storage of basic_format_arg must be contiguous. + std::vector> data_; + std::vector> named_info_; + + // Storage of arguments not fitting into basic_format_arg must grow + // without relocation because items in data_ refer to it. + detail::dynamic_arg_list dynamic_args_; + + friend class basic_format_args; + + unsigned long long get_types() const { + return detail::is_unpacked_bit | data_.size() | + (named_info_.empty() + ? 0ULL + : static_cast(detail::has_named_args_bit)); + } + + const basic_format_arg* data() const { + return named_info_.empty() ? data_.data() : data_.data() + 1; + } + + template void emplace_arg(const T& arg) { + data_.emplace_back(detail::make_arg(arg)); + } + + template + void emplace_arg(const detail::named_arg& arg) { + if (named_info_.empty()) { + constexpr const detail::named_arg_info* zero_ptr{nullptr}; + data_.insert(data_.begin(), {zero_ptr, 0}); + } + data_.emplace_back(detail::make_arg(detail::unwrap(arg.value))); + auto pop_one = [](std::vector>* data) { + data->pop_back(); + }; + std::unique_ptr>, decltype(pop_one)> + guard{&data_, pop_one}; + named_info_.push_back({arg.name, static_cast(data_.size() - 2u)}); + data_[0].value_.named_args = {named_info_.data(), named_info_.size()}; + guard.release(); + } + + public: + constexpr dynamic_format_arg_store() = default; + + /** + \rst + Adds an argument into the dynamic store for later passing to a formatting + function. + + Note that custom types and string types (but not string views) are copied + into the store dynamically allocating memory if necessary. + + **Example**:: + + fmt::dynamic_format_arg_store store; + store.push_back(42); + store.push_back("abc"); + store.push_back(1.5f); + std::string result = fmt::vformat("{} and {} and {}", store); + \endrst + */ + template void push_back(const T& arg) { + if (detail::const_check(need_copy::value)) + emplace_arg(dynamic_args_.push>(arg)); + else + emplace_arg(detail::unwrap(arg)); + } + + /** + \rst + Adds a reference to the argument into the dynamic store for later passing to + a formatting function. + + **Example**:: + + fmt::dynamic_format_arg_store store; + char band[] = "Rolling Stones"; + store.push_back(std::cref(band)); + band[9] = 'c'; // Changing str affects the output. + std::string result = fmt::vformat("{}", store); + // result == "Rolling Scones" + \endrst + */ + template void push_back(std::reference_wrapper arg) { + static_assert( + need_copy::value, + "objects of built-in types and string views are always copied"); + emplace_arg(arg.get()); + } + + /** + Adds named argument into the dynamic store for later passing to a formatting + function. ``std::reference_wrapper`` is supported to avoid copying of the + argument. The name is always copied into the store. + */ + template + void push_back(const detail::named_arg& arg) { + const char_type* arg_name = + dynamic_args_.push>(arg.name).c_str(); + if (detail::const_check(need_copy::value)) { + emplace_arg( + fmt::arg(arg_name, dynamic_args_.push>(arg.value))); + } else { + emplace_arg(fmt::arg(arg_name, arg.value)); + } + } + + /** Erase all elements from the store */ + void clear() { + data_.clear(); + named_info_.clear(); + dynamic_args_ = detail::dynamic_arg_list(); + } + + /** + \rst + Reserves space to store at least *new_cap* arguments including + *new_cap_named* named arguments. + \endrst + */ + void reserve(size_t new_cap, size_t new_cap_named) { + FMT_ASSERT(new_cap >= new_cap_named, + "Set of arguments includes set of named arguments"); + data_.reserve(new_cap); + named_info_.reserve(new_cap_named); + } +}; + +FMT_END_NAMESPACE + +#endif // FMT_ARGS_H_ diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h new file mode 100644 index 0000000..43daeeb --- /dev/null +++ b/include/fmt/chrono.h @@ -0,0 +1,2268 @@ +// Formatting library for C++ - chrono support +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_CHRONO_H_ +#define FMT_CHRONO_H_ + +#include +#include +#include // std::isfinite +#include // std::memcpy +#include +#include +#include +#include +#include + +#include "format.h" + +FMT_BEGIN_NAMESPACE + +// Check if std::chrono::local_t is available. +#ifndef FMT_USE_LOCAL_TIME +# ifdef __cpp_lib_chrono +# define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) +# else +# define FMT_USE_LOCAL_TIME 0 +# endif +#endif + +// Check if std::chrono::utc_timestamp is available. +#ifndef FMT_USE_UTC_TIME +# ifdef __cpp_lib_chrono +# define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) +# else +# define FMT_USE_UTC_TIME 0 +# endif +#endif + +// Enable tzset. +#ifndef FMT_USE_TZSET +// UWP doesn't provide _tzset. +# if FMT_HAS_INCLUDE("winapifamily.h") +# include +# endif +# if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \ + (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) +# define FMT_USE_TZSET 1 +# else +# define FMT_USE_TZSET 0 +# endif +#endif + +// Enable safe chrono durations, unless explicitly disabled. +#ifndef FMT_SAFE_DURATION_CAST +# define FMT_SAFE_DURATION_CAST 1 +#endif +#if FMT_SAFE_DURATION_CAST + +// For conversion between std::chrono::durations without undefined +// behaviour or erroneous results. +// This is a stripped down version of duration_cast, for inclusion in fmt. +// See https://github.com/pauldreik/safe_duration_cast +// +// Copyright Paul Dreik 2019 +namespace safe_duration_cast { + +template ::value && + std::numeric_limits::is_signed == + std::numeric_limits::is_signed)> +FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + ec = 0; + using F = std::numeric_limits; + using T = std::numeric_limits; + static_assert(F::is_integer, "From must be integral"); + static_assert(T::is_integer, "To must be integral"); + + // A and B are both signed, or both unsigned. + if (detail::const_check(F::digits <= T::digits)) { + // From fits in To without any problem. + } else { + // From does not always fit in To, resort to a dynamic check. + if (from < (T::min)() || from > (T::max)()) { + // outside range. + ec = 1; + return {}; + } + } + return static_cast(from); +} + +/** + * converts From to To, without loss. If the dynamic value of from + * can't be converted to To without loss, ec is set. + */ +template ::value && + std::numeric_limits::is_signed != + std::numeric_limits::is_signed)> +FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + ec = 0; + using F = std::numeric_limits; + using T = std::numeric_limits; + static_assert(F::is_integer, "From must be integral"); + static_assert(T::is_integer, "To must be integral"); + + if (detail::const_check(F::is_signed && !T::is_signed)) { + // From may be negative, not allowed! + if (fmt::detail::is_negative(from)) { + ec = 1; + return {}; + } + // From is positive. Can it always fit in To? + if (detail::const_check(F::digits > T::digits) && + from > static_cast(detail::max_value())) { + ec = 1; + return {}; + } + } + + if (detail::const_check(!F::is_signed && T::is_signed && + F::digits >= T::digits) && + from > static_cast(detail::max_value())) { + ec = 1; + return {}; + } + return static_cast(from); // Lossless conversion. +} + +template ::value)> +FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) { + ec = 0; + return from; +} // function + +// clang-format off +/** + * converts From to To if possible, otherwise ec is set. + * + * input | output + * ---------------------------------|--------------- + * NaN | NaN + * Inf | Inf + * normal, fits in output | converted (possibly lossy) + * normal, does not fit in output | ec is set + * subnormal | best effort + * -Inf | -Inf + */ +// clang-format on +template ::value)> +FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { + ec = 0; + using T = std::numeric_limits; + static_assert(std::is_floating_point::value, "From must be floating"); + static_assert(std::is_floating_point::value, "To must be floating"); + + // catch the only happy case + if (std::isfinite(from)) { + if (from >= T::lowest() && from <= (T::max)()) { + return static_cast(from); + } + // not within range. + ec = 1; + return {}; + } + + // nan and inf will be preserved + return static_cast(from); +} // function + +template ::value)> +FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) { + ec = 0; + static_assert(std::is_floating_point::value, "From must be floating"); + return from; +} + +/** + * safe duration cast between integral durations + */ +template ::value), + FMT_ENABLE_IF(std::is_integral::value)> +To safe_duration_cast(std::chrono::duration from, + int& ec) { + using From = std::chrono::duration; + ec = 0; + // the basic idea is that we need to convert from count() in the from type + // to count() in the To type, by multiplying it with this: + struct Factor + : std::ratio_divide {}; + + static_assert(Factor::num > 0, "num must be positive"); + static_assert(Factor::den > 0, "den must be positive"); + + // the conversion is like this: multiply from.count() with Factor::num + // /Factor::den and convert it to To::rep, all this without + // overflow/underflow. let's start by finding a suitable type that can hold + // both To, From and Factor::num + using IntermediateRep = + typename std::common_type::type; + + // safe conversion to IntermediateRep + IntermediateRep count = + lossless_integral_conversion(from.count(), ec); + if (ec) return {}; + // multiply with Factor::num without overflow or underflow + if (detail::const_check(Factor::num != 1)) { + const auto max1 = detail::max_value() / Factor::num; + if (count > max1) { + ec = 1; + return {}; + } + const auto min1 = + (std::numeric_limits::min)() / Factor::num; + if (detail::const_check(!std::is_unsigned::value) && + count < min1) { + ec = 1; + return {}; + } + count *= Factor::num; + } + + if (detail::const_check(Factor::den != 1)) count /= Factor::den; + auto tocount = lossless_integral_conversion(count, ec); + return ec ? To() : To(tocount); +} + +/** + * safe duration_cast between floating point durations + */ +template ::value), + FMT_ENABLE_IF(std::is_floating_point::value)> +To safe_duration_cast(std::chrono::duration from, + int& ec) { + using From = std::chrono::duration; + ec = 0; + if (std::isnan(from.count())) { + // nan in, gives nan out. easy. + return To{std::numeric_limits::quiet_NaN()}; + } + // maybe we should also check if from is denormal, and decide what to do about + // it. + + // +-inf should be preserved. + if (std::isinf(from.count())) { + return To{from.count()}; + } + + // the basic idea is that we need to convert from count() in the from type + // to count() in the To type, by multiplying it with this: + struct Factor + : std::ratio_divide {}; + + static_assert(Factor::num > 0, "num must be positive"); + static_assert(Factor::den > 0, "den must be positive"); + + // the conversion is like this: multiply from.count() with Factor::num + // /Factor::den and convert it to To::rep, all this without + // overflow/underflow. let's start by finding a suitable type that can hold + // both To, From and Factor::num + using IntermediateRep = + typename std::common_type::type; + + // force conversion of From::rep -> IntermediateRep to be safe, + // even if it will never happen be narrowing in this context. + IntermediateRep count = + safe_float_conversion(from.count(), ec); + if (ec) { + return {}; + } + + // multiply with Factor::num without overflow or underflow + if (detail::const_check(Factor::num != 1)) { + constexpr auto max1 = detail::max_value() / + static_cast(Factor::num); + if (count > max1) { + ec = 1; + return {}; + } + constexpr auto min1 = std::numeric_limits::lowest() / + static_cast(Factor::num); + if (count < min1) { + ec = 1; + return {}; + } + count *= static_cast(Factor::num); + } + + // this can't go wrong, right? den>0 is checked earlier. + if (detail::const_check(Factor::den != 1)) { + using common_t = typename std::common_type::type; + count /= static_cast(Factor::den); + } + + // convert to the to type, safely + using ToRep = typename To::rep; + + const ToRep tocount = safe_float_conversion(count, ec); + if (ec) { + return {}; + } + return To{tocount}; +} +} // namespace safe_duration_cast +#endif + +// Prevents expansion of a preceding token as a function-style macro. +// Usage: f FMT_NOMACRO() +#define FMT_NOMACRO + +namespace detail { +template struct null {}; +inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); } +inline null<> localtime_s(...) { return null<>(); } +inline null<> gmtime_r(...) { return null<>(); } +inline null<> gmtime_s(...) { return null<>(); } + +inline const std::locale& get_classic_locale() { + static const auto& locale = std::locale::classic(); + return locale; +} + +template struct codecvt_result { + static constexpr const size_t max_size = 32; + CodeUnit buf[max_size]; + CodeUnit* end; +}; +template +constexpr const size_t codecvt_result::max_size; + +template +void write_codecvt(codecvt_result& out, string_view in_buf, + const std::locale& loc) { +#if FMT_CLANG_VERSION +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated" + auto& f = std::use_facet>(loc); +# pragma clang diagnostic pop +#else + auto& f = std::use_facet>(loc); +#endif + auto mb = std::mbstate_t(); + const char* from_next = nullptr; + auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next, + std::begin(out.buf), std::end(out.buf), out.end); + if (result != std::codecvt_base::ok) + FMT_THROW(format_error("failed to format time")); +} + +template +auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) + -> OutputIt { + if (detail::is_utf8() && loc != get_classic_locale()) { + // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and + // gcc-4. +#if FMT_MSC_VERSION != 0 || \ + (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)) + // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 + // and newer. + using code_unit = wchar_t; +#else + using code_unit = char32_t; +#endif + + using unit_t = codecvt_result; + unit_t unit; + write_codecvt(unit, in, loc); + // In UTF-8 is used one to four one-byte code units. + auto u = + to_utf8>(); + if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) + FMT_THROW(format_error("failed to format time")); + return copy_str(u.c_str(), u.c_str() + u.size(), out); + } + return copy_str(in.data(), in.data() + in.size(), out); +} + +template ::value)> +auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) + -> OutputIt { + codecvt_result unit; + write_codecvt(unit, sv, loc); + return copy_str(unit.buf, unit.end, out); +} + +template ::value)> +auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) + -> OutputIt { + return write_encoded_tm_str(out, sv, loc); +} + +template +inline void do_write(buffer& buf, const std::tm& time, + const std::locale& loc, char format, char modifier) { + auto&& format_buf = formatbuf>(buf); + auto&& os = std::basic_ostream(&format_buf); + os.imbue(loc); + using iterator = std::ostreambuf_iterator; + const auto& facet = std::use_facet>(loc); + auto end = facet.put(os, os, Char(' '), &time, format, modifier); + if (end.failed()) FMT_THROW(format_error("failed to format time")); +} + +template ::value)> +auto write(OutputIt out, const std::tm& time, const std::locale& loc, + char format, char modifier = 0) -> OutputIt { + auto&& buf = get_buffer(out); + do_write(buf, time, loc, format, modifier); + return get_iterator(buf, out); +} + +template ::value)> +auto write(OutputIt out, const std::tm& time, const std::locale& loc, + char format, char modifier = 0) -> OutputIt { + auto&& buf = basic_memory_buffer(); + do_write(buf, time, loc, format, modifier); + return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); +} + +} // namespace detail + +FMT_BEGIN_EXPORT + +/** + Converts given time since epoch as ``std::time_t`` value into calendar time, + expressed in local time. Unlike ``std::localtime``, this function is + thread-safe on most platforms. + */ +inline std::tm localtime(std::time_t time) { + struct dispatcher { + std::time_t time_; + std::tm tm_; + + dispatcher(std::time_t t) : time_(t) {} + + bool run() { + using namespace fmt::detail; + return handle(localtime_r(&time_, &tm_)); + } + + bool handle(std::tm* tm) { return tm != nullptr; } + + bool handle(detail::null<>) { + using namespace fmt::detail; + return fallback(localtime_s(&tm_, &time_)); + } + + bool fallback(int res) { return res == 0; } + +#if !FMT_MSC_VERSION + bool fallback(detail::null<>) { + using namespace fmt::detail; + std::tm* tm = std::localtime(&time_); + if (tm) tm_ = *tm; + return tm != nullptr; + } +#endif + }; + dispatcher lt(time); + // Too big time values may be unsupported. + if (!lt.run()) FMT_THROW(format_error("time_t value out of range")); + return lt.tm_; +} + +#if FMT_USE_LOCAL_TIME +template +inline auto localtime(std::chrono::local_time time) -> std::tm { + return localtime(std::chrono::system_clock::to_time_t( + std::chrono::current_zone()->to_sys(time))); +} +#endif + +/** + Converts given time since epoch as ``std::time_t`` value into calendar time, + expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this + function is thread-safe on most platforms. + */ +inline std::tm gmtime(std::time_t time) { + struct dispatcher { + std::time_t time_; + std::tm tm_; + + dispatcher(std::time_t t) : time_(t) {} + + bool run() { + using namespace fmt::detail; + return handle(gmtime_r(&time_, &tm_)); + } + + bool handle(std::tm* tm) { return tm != nullptr; } + + bool handle(detail::null<>) { + using namespace fmt::detail; + return fallback(gmtime_s(&tm_, &time_)); + } + + bool fallback(int res) { return res == 0; } + +#if !FMT_MSC_VERSION + bool fallback(detail::null<>) { + std::tm* tm = std::gmtime(&time_); + if (tm) tm_ = *tm; + return tm != nullptr; + } +#endif + }; + dispatcher gt(time); + // Too big time values may be unsupported. + if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); + return gt.tm_; +} + +inline std::tm gmtime( + std::chrono::time_point time_point) { + return gmtime(std::chrono::system_clock::to_time_t(time_point)); +} + +FMT_BEGIN_DETAIL_NAMESPACE + +// DEPRECATED! +template +FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, + format_specs& specs) -> const Char* { + FMT_ASSERT(begin != end, ""); + auto align = align::none; + auto p = begin + code_point_length(begin); + if (end - p <= 0) p = begin; + for (;;) { + switch (to_ascii(*p)) { + case '<': + align = align::left; + break; + case '>': + align = align::right; + break; + case '^': + align = align::center; + break; + } + if (align != align::none) { + if (p != begin) { + auto c = *begin; + if (c == '}') return begin; + if (c == '{') { + throw_format_error("invalid fill character '{'"); + return begin; + } + specs.fill = {begin, to_unsigned(p - begin)}; + begin = p + 1; + } else { + ++begin; + } + break; + } else if (p == begin) { + break; + } + p = begin; + } + specs.align = align; + return begin; +} + +// Writes two-digit numbers a, b and c separated by sep to buf. +// The method by Pavel Novikov based on +// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/. +inline void write_digit2_separated(char* buf, unsigned a, unsigned b, + unsigned c, char sep) { + unsigned long long digits = + a | (b << 24) | (static_cast(c) << 48); + // Convert each value to BCD. + // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b. + // The difference is + // y - x = a * 6 + // a can be found from x: + // a = floor(x / 10) + // then + // y = x + a * 6 = x + floor(x / 10) * 6 + // floor(x / 10) is (x * 205) >> 11 (needs 16 bits). + digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6; + // Put low nibbles to high bytes and high nibbles to low bytes. + digits = ((digits & 0x00f00000f00000f0) >> 4) | + ((digits & 0x000f00000f00000f) << 8); + auto usep = static_cast(sep); + // Add ASCII '0' to each digit byte and insert separators. + digits |= 0x3030003030003030 | (usep << 16) | (usep << 40); + + constexpr const size_t len = 8; + if (const_check(is_big_endian())) { + char tmp[len]; + std::memcpy(tmp, &digits, len); + std::reverse_copy(tmp, tmp + len, buf); + } else { + std::memcpy(buf, &digits, len); + } +} + +template FMT_CONSTEXPR inline const char* get_units() { + if (std::is_same::value) return "as"; + if (std::is_same::value) return "fs"; + if (std::is_same::value) return "ps"; + if (std::is_same::value) return "ns"; + if (std::is_same::value) return "µs"; + if (std::is_same::value) return "ms"; + if (std::is_same::value) return "cs"; + if (std::is_same::value) return "ds"; + if (std::is_same>::value) return "s"; + if (std::is_same::value) return "das"; + if (std::is_same::value) return "hs"; + if (std::is_same::value) return "ks"; + if (std::is_same::value) return "Ms"; + if (std::is_same::value) return "Gs"; + if (std::is_same::value) return "Ts"; + if (std::is_same::value) return "Ps"; + if (std::is_same::value) return "Es"; + if (std::is_same>::value) return "m"; + if (std::is_same>::value) return "h"; + return nullptr; +} + +enum class numeric_system { + standard, + // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale. + alternative +}; + +// Glibc extensions for formatting numeric values. +enum class pad_type { + unspecified, + // Do not pad a numeric result string. + none, + // Pad a numeric result string with zeros even if the conversion specifier + // character uses space-padding by default. + zero, + // Pad a numeric result string with spaces. + space, +}; + +template +auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { + if (pad == pad_type::none) return out; + return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); +} + +template +auto write_padding(OutputIt out, pad_type pad) -> OutputIt { + if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0'; + return out; +} + +// Parses a put_time-like format string and invokes handler actions. +template +FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin, + const Char* end, + Handler&& handler) { + if (begin == end || *begin == '}') return begin; + if (*begin != '%') FMT_THROW(format_error("invalid format")); + auto ptr = begin; + pad_type pad = pad_type::unspecified; + while (ptr != end) { + auto c = *ptr; + if (c == '}') break; + if (c != '%') { + ++ptr; + continue; + } + if (begin != ptr) handler.on_text(begin, ptr); + ++ptr; // consume '%' + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr; + switch (c) { + case '_': + pad = pad_type::space; + ++ptr; + break; + case '-': + pad = pad_type::none; + ++ptr; + break; + case '0': + pad = pad_type::zero; + ++ptr; + break; + } + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case '%': + handler.on_text(ptr - 1, ptr); + break; + case 'n': { + const Char newline[] = {'\n'}; + handler.on_text(newline, newline + 1); + break; + } + case 't': { + const Char tab[] = {'\t'}; + handler.on_text(tab, tab + 1); + break; + } + // Year: + case 'Y': + handler.on_year(numeric_system::standard); + break; + case 'y': + handler.on_short_year(numeric_system::standard); + break; + case 'C': + handler.on_century(numeric_system::standard); + break; + case 'G': + handler.on_iso_week_based_year(); + break; + case 'g': + handler.on_iso_week_based_short_year(); + break; + // Day of the week: + case 'a': + handler.on_abbr_weekday(); + break; + case 'A': + handler.on_full_weekday(); + break; + case 'w': + handler.on_dec0_weekday(numeric_system::standard); + break; + case 'u': + handler.on_dec1_weekday(numeric_system::standard); + break; + // Month: + case 'b': + case 'h': + handler.on_abbr_month(); + break; + case 'B': + handler.on_full_month(); + break; + case 'm': + handler.on_dec_month(numeric_system::standard); + break; + // Day of the year/month: + case 'U': + handler.on_dec0_week_of_year(numeric_system::standard); + break; + case 'W': + handler.on_dec1_week_of_year(numeric_system::standard); + break; + case 'V': + handler.on_iso_week_of_year(numeric_system::standard); + break; + case 'j': + handler.on_day_of_year(); + break; + case 'd': + handler.on_day_of_month(numeric_system::standard); + break; + case 'e': + handler.on_day_of_month_space(numeric_system::standard); + break; + // Hour, minute, second: + case 'H': + handler.on_24_hour(numeric_system::standard, pad); + break; + case 'I': + handler.on_12_hour(numeric_system::standard, pad); + break; + case 'M': + handler.on_minute(numeric_system::standard, pad); + break; + case 'S': + handler.on_second(numeric_system::standard, pad); + break; + // Other: + case 'c': + handler.on_datetime(numeric_system::standard); + break; + case 'x': + handler.on_loc_date(numeric_system::standard); + break; + case 'X': + handler.on_loc_time(numeric_system::standard); + break; + case 'D': + handler.on_us_date(); + break; + case 'F': + handler.on_iso_date(); + break; + case 'r': + handler.on_12_hour_time(); + break; + case 'R': + handler.on_24_hour_time(); + break; + case 'T': + handler.on_iso_time(); + break; + case 'p': + handler.on_am_pm(); + break; + case 'Q': + handler.on_duration_value(); + break; + case 'q': + handler.on_duration_unit(); + break; + case 'z': + handler.on_utc_offset(numeric_system::standard); + break; + case 'Z': + handler.on_tz_name(); + break; + // Alternative representation: + case 'E': { + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case 'Y': + handler.on_year(numeric_system::alternative); + break; + case 'y': + handler.on_offset_year(); + break; + case 'C': + handler.on_century(numeric_system::alternative); + break; + case 'c': + handler.on_datetime(numeric_system::alternative); + break; + case 'x': + handler.on_loc_date(numeric_system::alternative); + break; + case 'X': + handler.on_loc_time(numeric_system::alternative); + break; + case 'z': + handler.on_utc_offset(numeric_system::alternative); + break; + default: + FMT_THROW(format_error("invalid format")); + } + break; + } + case 'O': + if (ptr == end) FMT_THROW(format_error("invalid format")); + c = *ptr++; + switch (c) { + case 'y': + handler.on_short_year(numeric_system::alternative); + break; + case 'm': + handler.on_dec_month(numeric_system::alternative); + break; + case 'U': + handler.on_dec0_week_of_year(numeric_system::alternative); + break; + case 'W': + handler.on_dec1_week_of_year(numeric_system::alternative); + break; + case 'V': + handler.on_iso_week_of_year(numeric_system::alternative); + break; + case 'd': + handler.on_day_of_month(numeric_system::alternative); + break; + case 'e': + handler.on_day_of_month_space(numeric_system::alternative); + break; + case 'w': + handler.on_dec0_weekday(numeric_system::alternative); + break; + case 'u': + handler.on_dec1_weekday(numeric_system::alternative); + break; + case 'H': + handler.on_24_hour(numeric_system::alternative, pad); + break; + case 'I': + handler.on_12_hour(numeric_system::alternative, pad); + break; + case 'M': + handler.on_minute(numeric_system::alternative, pad); + break; + case 'S': + handler.on_second(numeric_system::alternative, pad); + break; + case 'z': + handler.on_utc_offset(numeric_system::alternative); + break; + default: + FMT_THROW(format_error("invalid format")); + } + break; + default: + FMT_THROW(format_error("invalid format")); + } + begin = ptr; + } + if (begin != ptr) handler.on_text(begin, ptr); + return ptr; +} + +template struct null_chrono_spec_handler { + FMT_CONSTEXPR void unsupported() { + static_cast(this)->unsupported(); + } + FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_offset_year() { unsupported(); } + FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); } + FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); } + FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); } + FMT_CONSTEXPR void on_full_weekday() { unsupported(); } + FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_abbr_month() { unsupported(); } + FMT_CONSTEXPR void on_full_month() { unsupported(); } + FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_year() { unsupported(); } + FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_us_date() { unsupported(); } + FMT_CONSTEXPR void on_iso_date() { unsupported(); } + FMT_CONSTEXPR void on_12_hour_time() { unsupported(); } + FMT_CONSTEXPR void on_24_hour_time() { unsupported(); } + FMT_CONSTEXPR void on_iso_time() { unsupported(); } + FMT_CONSTEXPR void on_am_pm() { unsupported(); } + FMT_CONSTEXPR void on_duration_value() { unsupported(); } + FMT_CONSTEXPR void on_duration_unit() { unsupported(); } + FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); } + FMT_CONSTEXPR void on_tz_name() { unsupported(); } +}; + +struct tm_format_checker : null_chrono_spec_handler { + FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); } + + template + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + FMT_CONSTEXPR void on_year(numeric_system) {} + FMT_CONSTEXPR void on_short_year(numeric_system) {} + FMT_CONSTEXPR void on_offset_year() {} + FMT_CONSTEXPR void on_century(numeric_system) {} + FMT_CONSTEXPR void on_iso_week_based_year() {} + FMT_CONSTEXPR void on_iso_week_based_short_year() {} + FMT_CONSTEXPR void on_abbr_weekday() {} + FMT_CONSTEXPR void on_full_weekday() {} + FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {} + FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} + FMT_CONSTEXPR void on_abbr_month() {} + FMT_CONSTEXPR void on_full_month() {} + FMT_CONSTEXPR void on_dec_month(numeric_system) {} + FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {} + FMT_CONSTEXPR void on_day_of_year() {} + FMT_CONSTEXPR void on_day_of_month(numeric_system) {} + FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {} + FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_datetime(numeric_system) {} + FMT_CONSTEXPR void on_loc_date(numeric_system) {} + FMT_CONSTEXPR void on_loc_time(numeric_system) {} + FMT_CONSTEXPR void on_us_date() {} + FMT_CONSTEXPR void on_iso_date() {} + FMT_CONSTEXPR void on_12_hour_time() {} + FMT_CONSTEXPR void on_24_hour_time() {} + FMT_CONSTEXPR void on_iso_time() {} + FMT_CONSTEXPR void on_am_pm() {} + FMT_CONSTEXPR void on_utc_offset(numeric_system) {} + FMT_CONSTEXPR void on_tz_name() {} +}; + +inline const char* tm_wday_full_name(int wday) { + static constexpr const char* full_name_list[] = { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday"}; + return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; +} +inline const char* tm_wday_short_name(int wday) { + static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", + "Thu", "Fri", "Sat"}; + return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; +} + +inline const char* tm_mon_full_name(int mon) { + static constexpr const char* full_name_list[] = { + "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December"}; + return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; +} +inline const char* tm_mon_short_name(int mon) { + static constexpr const char* short_name_list[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", + }; + return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???"; +} + +template +struct has_member_data_tm_gmtoff : std::false_type {}; +template +struct has_member_data_tm_gmtoff> + : std::true_type {}; + +template +struct has_member_data_tm_zone : std::false_type {}; +template +struct has_member_data_tm_zone> + : std::true_type {}; + +#if FMT_USE_TZSET +inline void tzset_once() { + static bool init = []() -> bool { + _tzset(); + return true; + }(); + ignore_unused(init); +} +#endif + +// Converts value to Int and checks that it's in the range [0, upper). +template ::value)> +inline Int to_nonnegative_int(T value, Int upper) { + FMT_ASSERT(std::is_unsigned::value || + (value >= 0 && to_unsigned(value) <= to_unsigned(upper)), + "invalid value"); + (void)upper; + return static_cast(value); +} +template ::value)> +inline Int to_nonnegative_int(T value, Int upper) { + if (value < 0 || value > static_cast(upper)) + FMT_THROW(format_error("invalid value")); + return static_cast(value); +} + +constexpr long long pow10(std::uint32_t n) { + return n == 0 ? 1 : 10 * pow10(n - 1); +} + +// Counts the number of fractional digits in the range [0, 18] according to the +// C++20 spec. If more than 18 fractional digits are required then returns 6 for +// microseconds precision. +template () / 10)> +struct count_fractional_digits { + static constexpr int value = + Num % Den == 0 ? N : count_fractional_digits::value; +}; + +// Base case that doesn't instantiate any more templates +// in order to avoid overflow. +template +struct count_fractional_digits { + static constexpr int value = (Num % Den == 0) ? N : 6; +}; + +// Format subseconds which are given as an integer type with an appropriate +// number of digits. +template +void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { + constexpr auto num_fractional_digits = + count_fractional_digits::value; + + using subsecond_precision = std::chrono::duration< + typename std::common_type::type, + std::ratio<1, detail::pow10(num_fractional_digits)>>; + + const auto fractional = + d - std::chrono::duration_cast(d); + const auto subseconds = + std::chrono::treat_as_floating_point< + typename subsecond_precision::rep>::value + ? fractional.count() + : std::chrono::duration_cast(fractional).count(); + auto n = static_cast>(subseconds); + const int num_digits = detail::count_digits(n); + + int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); + if (precision < 0) { + FMT_ASSERT(!std::is_floating_point::value, ""); + if (std::ratio_less::value) { + *out++ = '.'; + out = std::fill_n(out, leading_zeroes, '0'); + out = format_decimal(out, n, num_digits).end; + } + } else { + *out++ = '.'; + leading_zeroes = (std::min)(leading_zeroes, precision); + out = std::fill_n(out, leading_zeroes, '0'); + int remaining = precision - leading_zeroes; + if (remaining != 0 && remaining < num_digits) { + n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining))); + out = format_decimal(out, n, remaining).end; + return; + } + out = format_decimal(out, n, num_digits).end; + remaining -= num_digits; + out = std::fill_n(out, remaining, '0'); + } +} + +// Format subseconds which are given as a floating point type with an +// appropriate number of digits. We cannot pass the Duration here, as we +// explicitly need to pass the Rep value in the chrono_formatter. +template +void write_floating_seconds(memory_buffer& buf, Duration duration, + int num_fractional_digits = -1) { + using rep = typename Duration::rep; + FMT_ASSERT(std::is_floating_point::value, ""); + + auto val = duration.count(); + + if (num_fractional_digits < 0) { + // For `std::round` with fallback to `round`: + // On some toolchains `std::round` is not available (e.g. GCC 6). + using namespace std; + num_fractional_digits = + count_fractional_digits::value; + if (num_fractional_digits < 6 && static_cast(round(val)) != val) + num_fractional_digits = 6; + } + + format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), + std::fmod(val * static_cast(Duration::period::num) / + static_cast(Duration::period::den), + static_cast(60)), + num_fractional_digits); +} + +template +class tm_writer { + private: + static constexpr int days_per_week = 7; + + const std::locale& loc_; + const bool is_classic_; + OutputIt out_; + const Duration* subsecs_; + const std::tm& tm_; + + auto tm_sec() const noexcept -> int { + FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, ""); + return tm_.tm_sec; + } + auto tm_min() const noexcept -> int { + FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, ""); + return tm_.tm_min; + } + auto tm_hour() const noexcept -> int { + FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, ""); + return tm_.tm_hour; + } + auto tm_mday() const noexcept -> int { + FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, ""); + return tm_.tm_mday; + } + auto tm_mon() const noexcept -> int { + FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, ""); + return tm_.tm_mon; + } + auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; } + auto tm_wday() const noexcept -> int { + FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, ""); + return tm_.tm_wday; + } + auto tm_yday() const noexcept -> int { + FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, ""); + return tm_.tm_yday; + } + + auto tm_hour12() const noexcept -> int { + const auto h = tm_hour(); + const auto z = h < 12 ? h : h - 12; + return z == 0 ? 12 : z; + } + + // POSIX and the C Standard are unclear or inconsistent about what %C and %y + // do if the year is negative or exceeds 9999. Use the convention that %C + // concatenated with %y yields the same output as %Y, and that %Y contains at + // least 4 characters, with more only if necessary. + auto split_year_lower(long long year) const noexcept -> int { + auto l = year % 100; + if (l < 0) l = -l; // l in [0, 99] + return static_cast(l); + } + + // Algorithm: + // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_from_a_month_and_day_of_the_month_or_ordinal_date + auto iso_year_weeks(long long curr_year) const noexcept -> int { + const auto prev_year = curr_year - 1; + const auto curr_p = + (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % + days_per_week; + const auto prev_p = + (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % + days_per_week; + return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0); + } + auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int { + return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / + days_per_week; + } + auto tm_iso_week_year() const noexcept -> long long { + const auto year = tm_year(); + const auto w = iso_week_num(tm_yday(), tm_wday()); + if (w < 1) return year - 1; + if (w > iso_year_weeks(year)) return year + 1; + return year; + } + auto tm_iso_week_of_year() const noexcept -> int { + const auto year = tm_year(); + const auto w = iso_week_num(tm_yday(), tm_wday()); + if (w < 1) return iso_year_weeks(year - 1); + if (w > iso_year_weeks(year)) return 1; + return w; + } + + void write1(int value) { + *out_++ = static_cast('0' + to_unsigned(value) % 10); + } + void write2(int value) { + const char* d = digits2(to_unsigned(value) % 100); + *out_++ = *d++; + *out_++ = *d; + } + void write2(int value, pad_type pad) { + unsigned int v = to_unsigned(value) % 100; + if (v >= 10) { + const char* d = digits2(v); + *out_++ = *d++; + *out_++ = *d; + } else { + out_ = detail::write_padding(out_, pad); + *out_++ = static_cast('0' + v); + } + } + + void write_year_extended(long long year) { + // At least 4 characters. + int width = 4; + if (year < 0) { + *out_++ = '-'; + year = 0 - year; + --width; + } + uint32_or_64_or_128_t n = to_unsigned(year); + const int num_digits = count_digits(n); + if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0'); + out_ = format_decimal(out_, n, num_digits).end; + } + void write_year(long long year) { + if (year >= 0 && year < 10000) { + write2(static_cast(year / 100)); + write2(static_cast(year % 100)); + } else { + write_year_extended(year); + } + } + + void write_utc_offset(long offset, numeric_system ns) { + if (offset < 0) { + *out_++ = '-'; + offset = -offset; + } else { + *out_++ = '+'; + } + offset /= 60; + write2(static_cast(offset / 60)); + if (ns != numeric_system::standard) *out_++ = ':'; + write2(static_cast(offset % 60)); + } + template ::value)> + void format_utc_offset_impl(const T& tm, numeric_system ns) { + write_utc_offset(tm.tm_gmtoff, ns); + } + template ::value)> + void format_utc_offset_impl(const T& tm, numeric_system ns) { +#if defined(_WIN32) && defined(_UCRT) +# if FMT_USE_TZSET + tzset_once(); +# endif + long offset = 0; + _get_timezone(&offset); + if (tm.tm_isdst) { + long dstbias = 0; + _get_dstbias(&dstbias); + offset += dstbias; + } + write_utc_offset(-offset, ns); +#else + if (ns == numeric_system::standard) return format_localized('z'); + + // Extract timezone offset from timezone conversion functions. + std::tm gtm = tm; + std::time_t gt = std::mktime(>m); + std::tm ltm = gmtime(gt); + std::time_t lt = std::mktime(<m); + long offset = gt - lt; + write_utc_offset(offset, ns); +#endif + } + + template ::value)> + void format_tz_name_impl(const T& tm) { + if (is_classic_) + out_ = write_tm_str(out_, tm.tm_zone, loc_); + else + format_localized('Z'); + } + template ::value)> + void format_tz_name_impl(const T&) { + format_localized('Z'); + } + + void format_localized(char format, char modifier = 0) { + out_ = write(out_, tm_, loc_, format, modifier); + } + + public: + tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm, + const Duration* subsecs = nullptr) + : loc_(loc), + is_classic_(loc_ == get_classic_locale()), + out_(out), + subsecs_(subsecs), + tm_(tm) {} + + OutputIt out() const { return out_; } + + FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { + out_ = copy_str(begin, end, out_); + } + + void on_abbr_weekday() { + if (is_classic_) + out_ = write(out_, tm_wday_short_name(tm_wday())); + else + format_localized('a'); + } + void on_full_weekday() { + if (is_classic_) + out_ = write(out_, tm_wday_full_name(tm_wday())); + else + format_localized('A'); + } + void on_dec0_weekday(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday()); + format_localized('w', 'O'); + } + void on_dec1_weekday(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto wday = tm_wday(); + write1(wday == 0 ? days_per_week : wday); + } else { + format_localized('u', 'O'); + } + } + + void on_abbr_month() { + if (is_classic_) + out_ = write(out_, tm_mon_short_name(tm_mon())); + else + format_localized('b'); + } + void on_full_month() { + if (is_classic_) + out_ = write(out_, tm_mon_full_name(tm_mon())); + else + format_localized('B'); + } + + void on_datetime(numeric_system ns) { + if (is_classic_) { + on_abbr_weekday(); + *out_++ = ' '; + on_abbr_month(); + *out_++ = ' '; + on_day_of_month_space(numeric_system::standard); + *out_++ = ' '; + on_iso_time(); + *out_++ = ' '; + on_year(numeric_system::standard); + } else { + format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); + } + } + void on_loc_date(numeric_system ns) { + if (is_classic_) + on_us_date(); + else + format_localized('x', ns == numeric_system::standard ? '\0' : 'E'); + } + void on_loc_time(numeric_system ns) { + if (is_classic_) + on_iso_time(); + else + format_localized('X', ns == numeric_system::standard ? '\0' : 'E'); + } + void on_us_date() { + char buf[8]; + write_digit2_separated(buf, to_unsigned(tm_mon() + 1), + to_unsigned(tm_mday()), + to_unsigned(split_year_lower(tm_year())), '/'); + out_ = copy_str(std::begin(buf), std::end(buf), out_); + } + void on_iso_date() { + auto year = tm_year(); + char buf[10]; + size_t offset = 0; + if (year >= 0 && year < 10000) { + copy2(buf, digits2(static_cast(year / 100))); + } else { + offset = 4; + write_year_extended(year); + year = 0; + } + write_digit2_separated(buf + 2, static_cast(year % 100), + to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), + '-'); + out_ = copy_str(std::begin(buf) + offset, std::end(buf), out_); + } + + void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); } + void on_tz_name() { format_tz_name_impl(tm_); } + + void on_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write_year(tm_year()); + format_localized('Y', 'E'); + } + void on_short_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2(split_year_lower(tm_year())); + format_localized('y', 'O'); + } + void on_offset_year() { + if (is_classic_) return write2(split_year_lower(tm_year())); + format_localized('y', 'E'); + } + + void on_century(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto year = tm_year(); + auto upper = year / 100; + if (year >= -99 && year < 0) { + // Zero upper on negative year. + *out_++ = '-'; + *out_++ = '0'; + } else if (upper >= 0 && upper < 100) { + write2(static_cast(upper)); + } else { + out_ = write(out_, upper); + } + } else { + format_localized('C', 'E'); + } + } + + void on_dec_month(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_mon() + 1); + format_localized('m', 'O'); + } + + void on_dec0_week_of_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week); + format_localized('U', 'O'); + } + void on_dec1_week_of_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto wday = tm_wday(); + write2((tm_yday() + days_per_week - + (wday == 0 ? (days_per_week - 1) : (wday - 1))) / + days_per_week); + } else { + format_localized('W', 'O'); + } + } + void on_iso_week_of_year(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_iso_week_of_year()); + format_localized('V', 'O'); + } + + void on_iso_week_based_year() { write_year(tm_iso_week_year()); } + void on_iso_week_based_short_year() { + write2(split_year_lower(tm_iso_week_year())); + } + + void on_day_of_year() { + auto yday = tm_yday() + 1; + write1(yday / 100); + write2(yday % 100); + } + void on_day_of_month(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday()); + format_localized('d', 'O'); + } + void on_day_of_month_space(numeric_system ns) { + if (is_classic_ || ns == numeric_system::standard) { + auto mday = to_unsigned(tm_mday()) % 100; + const char* d2 = digits2(mday); + *out_++ = mday < 10 ? ' ' : d2[0]; + *out_++ = d2[1]; + } else { + format_localized('e', 'O'); + } + } + + void on_24_hour(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_hour(), pad); + format_localized('H', 'O'); + } + void on_12_hour(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_hour12(), pad); + format_localized('I', 'O'); + } + void on_minute(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) + return write2(tm_min(), pad); + format_localized('M', 'O'); + } + + void on_second(numeric_system ns, pad_type pad) { + if (is_classic_ || ns == numeric_system::standard) { + write2(tm_sec(), pad); + if (subsecs_) { + if (std::is_floating_point::value) { + auto buf = memory_buffer(); + write_floating_seconds(buf, *subsecs_); + if (buf.size() > 1) { + // Remove the leading "0", write something like ".123". + out_ = std::copy(buf.begin() + 1, buf.end(), out_); + } + } else { + write_fractional_seconds(out_, *subsecs_); + } + } + } else { + // Currently no formatting of subseconds when a locale is set. + format_localized('S', 'O'); + } + } + + void on_12_hour_time() { + if (is_classic_) { + char buf[8]; + write_digit2_separated(buf, to_unsigned(tm_hour12()), + to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); + out_ = copy_str(std::begin(buf), std::end(buf), out_); + *out_++ = ' '; + on_am_pm(); + } else { + format_localized('r'); + } + } + void on_24_hour_time() { + write2(tm_hour()); + *out_++ = ':'; + write2(tm_min()); + } + void on_iso_time() { + on_24_hour_time(); + *out_++ = ':'; + on_second(numeric_system::standard, pad_type::unspecified); + } + + void on_am_pm() { + if (is_classic_) { + *out_++ = tm_hour() < 12 ? 'A' : 'P'; + *out_++ = 'M'; + } else { + format_localized('p'); + } + } + + // These apply to chrono durations but not tm. + void on_duration_value() {} + void on_duration_unit() {} +}; + +struct chrono_format_checker : null_chrono_spec_handler { + bool has_precision_integral = false; + + FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); } + + template + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} + FMT_CONSTEXPR void on_12_hour_time() {} + FMT_CONSTEXPR void on_24_hour_time() {} + FMT_CONSTEXPR void on_iso_time() {} + FMT_CONSTEXPR void on_am_pm() {} + FMT_CONSTEXPR void on_duration_value() const { + if (has_precision_integral) { + FMT_THROW(format_error("precision not allowed for this argument type")); + } + } + FMT_CONSTEXPR void on_duration_unit() {} +}; + +template ::value&& has_isfinite::value)> +inline bool isfinite(T) { + return true; +} + +template ::value)> +inline T mod(T x, int y) { + return x % static_cast(y); +} +template ::value)> +inline T mod(T x, int y) { + return std::fmod(x, static_cast(y)); +} + +// If T is an integral type, maps T to its unsigned counterpart, otherwise +// leaves it unchanged (unlike std::make_unsigned). +template ::value> +struct make_unsigned_or_unchanged { + using type = T; +}; + +template struct make_unsigned_or_unchanged { + using type = typename std::make_unsigned::type; +}; + +#if FMT_SAFE_DURATION_CAST +// throwing version of safe_duration_cast +template +To fmt_safe_duration_cast(std::chrono::duration from) { + int ec; + To to = safe_duration_cast::safe_duration_cast(from, ec); + if (ec) FMT_THROW(format_error("cannot format duration")); + return to; +} +#endif + +template ::value)> +inline std::chrono::duration get_milliseconds( + std::chrono::duration d) { + // this may overflow and/or the result may not fit in the + // target type. +#if FMT_SAFE_DURATION_CAST + using CommonSecondsType = + typename std::common_type::type; + const auto d_as_common = fmt_safe_duration_cast(d); + const auto d_as_whole_seconds = + fmt_safe_duration_cast(d_as_common); + // this conversion should be nonproblematic + const auto diff = d_as_common - d_as_whole_seconds; + const auto ms = + fmt_safe_duration_cast>(diff); + return ms; +#else + auto s = std::chrono::duration_cast(d); + return std::chrono::duration_cast(d - s); +#endif +} + +template ::value)> +OutputIt format_duration_value(OutputIt out, Rep val, int) { + return write(out, val); +} + +template ::value)> +OutputIt format_duration_value(OutputIt out, Rep val, int precision) { + auto specs = format_specs(); + specs.precision = precision; + specs.type = precision >= 0 ? presentation_type::fixed_lower + : presentation_type::general_lower; + return write(out, val, specs); +} + +template +OutputIt copy_unit(string_view unit, OutputIt out, Char) { + return std::copy(unit.begin(), unit.end(), out); +} + +template +OutputIt copy_unit(string_view unit, OutputIt out, wchar_t) { + // This works when wchar_t is UTF-32 because units only contain characters + // that have the same representation in UTF-16 and UTF-32. + utf8_to_utf16 u(unit); + return std::copy(u.c_str(), u.c_str() + u.size(), out); +} + +template +OutputIt format_duration_unit(OutputIt out) { + if (const char* unit = get_units()) + return copy_unit(string_view(unit), out, Char()); + *out++ = '['; + out = write(out, Period::num); + if (const_check(Period::den != 1)) { + *out++ = '/'; + out = write(out, Period::den); + } + *out++ = ']'; + *out++ = 's'; + return out; +} + +class get_locale { + private: + union { + std::locale locale_; + }; + bool has_locale_ = false; + + public: + get_locale(bool localized, locale_ref loc) : has_locale_(localized) { + if (localized) + ::new (&locale_) std::locale(loc.template get()); + } + ~get_locale() { + if (has_locale_) locale_.~locale(); + } + operator const std::locale&() const { + return has_locale_ ? locale_ : get_classic_locale(); + } +}; + +template +struct chrono_formatter { + FormatContext& context; + OutputIt out; + int precision; + bool localized = false; + // rep is unsigned to avoid overflow. + using rep = + conditional_t::value && sizeof(Rep) < sizeof(int), + unsigned, typename make_unsigned_or_unchanged::type>; + rep val; + using seconds = std::chrono::duration; + seconds s; + using milliseconds = std::chrono::duration; + bool negative; + + using char_type = typename FormatContext::char_type; + using tm_writer_type = tm_writer; + + chrono_formatter(FormatContext& ctx, OutputIt o, + std::chrono::duration d) + : context(ctx), + out(o), + val(static_cast(d.count())), + negative(false) { + if (d.count() < 0) { + val = 0 - val; + negative = true; + } + + // this may overflow and/or the result may not fit in the + // target type. +#if FMT_SAFE_DURATION_CAST + // might need checked conversion (rep!=Rep) + auto tmpval = std::chrono::duration(val); + s = fmt_safe_duration_cast(tmpval); +#else + s = std::chrono::duration_cast( + std::chrono::duration(val)); +#endif + } + + // returns true if nan or inf, writes to out. + bool handle_nan_inf() { + if (isfinite(val)) { + return false; + } + if (isnan(val)) { + write_nan(); + return true; + } + // must be +-inf + if (val > 0) { + write_pinf(); + } else { + write_ninf(); + } + return true; + } + + Rep hour() const { return static_cast(mod((s.count() / 3600), 24)); } + + Rep hour12() const { + Rep hour = static_cast(mod((s.count() / 3600), 12)); + return hour <= 0 ? 12 : hour; + } + + Rep minute() const { return static_cast(mod((s.count() / 60), 60)); } + Rep second() const { return static_cast(mod(s.count(), 60)); } + + std::tm time() const { + auto time = std::tm(); + time.tm_hour = to_nonnegative_int(hour(), 24); + time.tm_min = to_nonnegative_int(minute(), 60); + time.tm_sec = to_nonnegative_int(second(), 60); + return time; + } + + void write_sign() { + if (negative) { + *out++ = '-'; + negative = false; + } + } + + void write(Rep value, int width, pad_type pad = pad_type::unspecified) { + write_sign(); + if (isnan(value)) return write_nan(); + uint32_or_64_or_128_t n = + to_unsigned(to_nonnegative_int(value, max_value())); + int num_digits = detail::count_digits(n); + if (width > num_digits) { + out = detail::write_padding(out, pad, width - num_digits); + } + out = format_decimal(out, n, num_digits).end; + } + + void write_nan() { std::copy_n("nan", 3, out); } + void write_pinf() { std::copy_n("inf", 3, out); } + void write_ninf() { std::copy_n("-inf", 4, out); } + + template + void format_tm(const tm& time, Callback cb, Args... args) { + if (isnan(val)) return write_nan(); + get_locale loc(localized, context.locale()); + auto w = tm_writer_type(loc, out, time); + (w.*cb)(args...); + out = w.out(); + } + + void on_text(const char_type* begin, const char_type* end) { + std::copy(begin, end, out); + } + + // These are not implemented because durations don't have date information. + void on_abbr_weekday() {} + void on_full_weekday() {} + void on_dec0_weekday(numeric_system) {} + void on_dec1_weekday(numeric_system) {} + void on_abbr_month() {} + void on_full_month() {} + void on_datetime(numeric_system) {} + void on_loc_date(numeric_system) {} + void on_loc_time(numeric_system) {} + void on_us_date() {} + void on_iso_date() {} + void on_utc_offset(numeric_system) {} + void on_tz_name() {} + void on_year(numeric_system) {} + void on_short_year(numeric_system) {} + void on_offset_year() {} + void on_century(numeric_system) {} + void on_iso_week_based_year() {} + void on_iso_week_based_short_year() {} + void on_dec_month(numeric_system) {} + void on_dec0_week_of_year(numeric_system) {} + void on_dec1_week_of_year(numeric_system) {} + void on_iso_week_of_year(numeric_system) {} + void on_day_of_year() {} + void on_day_of_month(numeric_system) {} + void on_day_of_month_space(numeric_system) {} + + void on_24_hour(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) return write(hour(), 2, pad); + auto time = tm(); + time.tm_hour = to_nonnegative_int(hour(), 24); + format_tm(time, &tm_writer_type::on_24_hour, ns, pad); + } + + void on_12_hour(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) return write(hour12(), 2, pad); + auto time = tm(); + time.tm_hour = to_nonnegative_int(hour12(), 12); + format_tm(time, &tm_writer_type::on_12_hour, ns, pad); + } + + void on_minute(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) return write(minute(), 2, pad); + auto time = tm(); + time.tm_min = to_nonnegative_int(minute(), 60); + format_tm(time, &tm_writer_type::on_minute, ns, pad); + } + + void on_second(numeric_system ns, pad_type pad) { + if (handle_nan_inf()) return; + + if (ns == numeric_system::standard) { + if (std::is_floating_point::value) { + auto buf = memory_buffer(); + write_floating_seconds(buf, std::chrono::duration(val), + precision); + if (negative) *out++ = '-'; + if (buf.size() < 2 || buf[1] == '.') { + out = detail::write_padding(out, pad); + } + out = std::copy(buf.begin(), buf.end(), out); + } else { + write(second(), 2, pad); + write_fractional_seconds( + out, std::chrono::duration(val), precision); + } + return; + } + auto time = tm(); + time.tm_sec = to_nonnegative_int(second(), 60); + format_tm(time, &tm_writer_type::on_second, ns, pad); + } + + void on_12_hour_time() { + if (handle_nan_inf()) return; + format_tm(time(), &tm_writer_type::on_12_hour_time); + } + + void on_24_hour_time() { + if (handle_nan_inf()) { + *out++ = ':'; + handle_nan_inf(); + return; + } + + write(hour(), 2); + *out++ = ':'; + write(minute(), 2); + } + + void on_iso_time() { + on_24_hour_time(); + *out++ = ':'; + if (handle_nan_inf()) return; + on_second(numeric_system::standard, pad_type::unspecified); + } + + void on_am_pm() { + if (handle_nan_inf()) return; + format_tm(time(), &tm_writer_type::on_am_pm); + } + + void on_duration_value() { + if (handle_nan_inf()) return; + write_sign(); + out = format_duration_value(out, val, precision); + } + + void on_duration_unit() { + out = format_duration_unit(out); + } +}; + +FMT_END_DETAIL_NAMESPACE + +#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 +using weekday = std::chrono::weekday; +#else +// A fallback version of weekday. +class weekday { + private: + unsigned char value; + + public: + weekday() = default; + explicit constexpr weekday(unsigned wd) noexcept + : value(static_cast(wd != 7 ? wd : 0)) {} + constexpr unsigned c_encoding() const noexcept { return value; } +}; + +class year_month_day {}; +#endif + +// A rudimentary weekday formatter. +template struct formatter { + private: + bool localized = false; + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto begin = ctx.begin(), end = ctx.end(); + if (begin != end && *begin == 'L') { + ++begin; + localized = true; + } + return begin; + } + + template + auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { + auto time = std::tm(); + time.tm_wday = static_cast(wd.c_encoding()); + detail::get_locale loc(localized, ctx.locale()); + auto w = detail::tm_writer(loc, ctx.out(), time); + w.on_abbr_weekday(); + return w.out(); + } +}; + +template +struct formatter, Char> { + private: + format_specs specs; + int precision = -1; + using arg_ref_type = detail::arg_ref; + arg_ref_type width_ref; + arg_ref_type precision_ref; + bool localized = false; + basic_string_view format_str; + using duration = std::chrono::duration; + + using iterator = typename basic_format_parse_context::iterator; + struct parse_range { + iterator begin; + iterator end; + }; + + FMT_CONSTEXPR parse_range do_parse(basic_format_parse_context& ctx) { + auto begin = ctx.begin(), end = ctx.end(); + if (begin == end || *begin == '}') return {begin, begin}; + + begin = detail::parse_align(begin, end, specs); + if (begin == end) return {begin, begin}; + + begin = detail::parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); + if (begin == end) return {begin, begin}; + + auto checker = detail::chrono_format_checker(); + if (*begin == '.') { + checker.has_precision_integral = !std::is_floating_point::value; + begin = + detail::parse_precision(begin, end, precision, precision_ref, ctx); + } + if (begin != end && *begin == 'L') { + ++begin; + localized = true; + } + end = detail::parse_chrono_format(begin, end, checker); + return {begin, end}; + } + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto range = do_parse(ctx); + format_str = basic_string_view( + &*range.begin, detail::to_unsigned(range.end - range.begin)); + return range.end; + } + + template + auto format(const duration& d, FormatContext& ctx) const + -> decltype(ctx.out()) { + auto specs_copy = specs; + auto precision_copy = precision; + auto begin = format_str.begin(), end = format_str.end(); + // As a possible future optimization, we could avoid extra copying if width + // is not specified. + basic_memory_buffer buf; + auto out = std::back_inserter(buf); + detail::handle_dynamic_spec(specs_copy.width, + width_ref, ctx); + detail::handle_dynamic_spec(precision_copy, + precision_ref, ctx); + if (begin == end || *begin == '}') { + out = detail::format_duration_value(out, d.count(), precision_copy); + detail::format_duration_unit(out); + } else { + detail::chrono_formatter f( + ctx, out, d); + f.precision = precision_copy; + f.localized = localized; + detail::parse_chrono_format(begin, end, f); + } + return detail::write( + ctx.out(), basic_string_view(buf.data(), buf.size()), specs_copy); + } +}; + +template +struct formatter, + Char> : formatter { + FMT_CONSTEXPR formatter() { + this->format_str = detail::string_literal{}; + } + + template + auto format(std::chrono::time_point val, + FormatContext& ctx) const -> decltype(ctx.out()) { + using period = typename Duration::period; + if (period::num != 1 || period::den != 1 || + std::is_floating_point::value) { + const auto epoch = val.time_since_epoch(); + auto subsecs = std::chrono::duration_cast( + epoch - std::chrono::duration_cast(epoch)); + + if (subsecs.count() < 0) { + auto second = std::chrono::duration_cast( + std::chrono::seconds(1)); + if (epoch.count() < ((Duration::min)() + second).count()) + FMT_THROW(format_error("duration is too small")); + subsecs += second; + val -= second; + } + + return formatter::do_format( + gmtime(std::chrono::time_point_cast(val)), ctx, + &subsecs); + } + + return formatter::format( + gmtime(std::chrono::time_point_cast(val)), ctx); + } +}; + +#if FMT_USE_LOCAL_TIME +template +struct formatter, Char> + : formatter { + FMT_CONSTEXPR formatter() { + this->format_str = detail::string_literal{}; + } + + template + auto format(std::chrono::local_time val, FormatContext& ctx) const + -> decltype(ctx.out()) { + using period = typename Duration::period; + if (period::num != 1 || period::den != 1 || + std::is_floating_point::value) { + const auto epoch = val.time_since_epoch(); + const auto subsecs = std::chrono::duration_cast( + epoch - std::chrono::duration_cast(epoch)); + + return formatter::do_format( + localtime(std::chrono::time_point_cast(val)), + ctx, &subsecs); + } + + return formatter::format( + localtime(std::chrono::time_point_cast(val)), + ctx); + } +}; +#endif + +#if FMT_USE_UTC_TIME +template +struct formatter, + Char> + : formatter, + Char> { + template + auto format(std::chrono::time_point val, + FormatContext& ctx) const -> decltype(ctx.out()) { + return formatter< + std::chrono::time_point, + Char>::format(std::chrono::utc_clock::to_sys(val), ctx); + } +}; +#endif + +template struct formatter { + private: + format_specs specs; + detail::arg_ref width_ref; + + protected: + basic_string_view format_str; + + FMT_CONSTEXPR auto do_parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + auto begin = ctx.begin(), end = ctx.end(); + if (begin == end || *begin == '}') return begin; + + begin = detail::parse_align(begin, end, specs); + if (begin == end) return end; + + begin = detail::parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); + if (begin == end) return end; + + end = detail::parse_chrono_format(begin, end, detail::tm_format_checker()); + // Replace default format_str only if the new spec is not empty. + if (end != begin) format_str = {begin, detail::to_unsigned(end - begin)}; + return end; + } + + template + auto do_format(const std::tm& tm, FormatContext& ctx, + const Duration* subsecs) const -> decltype(ctx.out()) { + auto specs_copy = specs; + basic_memory_buffer buf; + auto out = std::back_inserter(buf); + detail::handle_dynamic_spec(specs_copy.width, + width_ref, ctx); + + const auto loc_ref = ctx.locale(); + detail::get_locale loc(static_cast(loc_ref), loc_ref); + auto w = + detail::tm_writer(loc, out, tm, subsecs); + detail::parse_chrono_format(format_str.begin(), format_str.end(), w); + return detail::write( + ctx.out(), basic_string_view(buf.data(), buf.size()), specs_copy); + } + + public: + FMT_CONSTEXPR auto parse(basic_format_parse_context& ctx) + -> decltype(ctx.begin()) { + return this->do_parse(ctx); + } + + template + auto format(const std::tm& tm, FormatContext& ctx) const + -> decltype(ctx.out()) { + return do_format(tm, ctx, nullptr); + } +}; + +FMT_END_EXPORT +FMT_END_NAMESPACE + +#endif // FMT_CHRONO_H_ diff --git a/include/fmt/color.h b/include/fmt/color.h new file mode 100644 index 0000000..d175448 --- /dev/null +++ b/include/fmt/color.h @@ -0,0 +1,633 @@ +// Formatting library for C++ - color support +// +// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_COLOR_H_ +#define FMT_COLOR_H_ + +#include "format.h" + +FMT_BEGIN_NAMESPACE +FMT_BEGIN_EXPORT + +enum class color : uint32_t { + alice_blue = 0xF0F8FF, // rgb(240,248,255) + antique_white = 0xFAEBD7, // rgb(250,235,215) + aqua = 0x00FFFF, // rgb(0,255,255) + aquamarine = 0x7FFFD4, // rgb(127,255,212) + azure = 0xF0FFFF, // rgb(240,255,255) + beige = 0xF5F5DC, // rgb(245,245,220) + bisque = 0xFFE4C4, // rgb(255,228,196) + black = 0x000000, // rgb(0,0,0) + blanched_almond = 0xFFEBCD, // rgb(255,235,205) + blue = 0x0000FF, // rgb(0,0,255) + blue_violet = 0x8A2BE2, // rgb(138,43,226) + brown = 0xA52A2A, // rgb(165,42,42) + burly_wood = 0xDEB887, // rgb(222,184,135) + cadet_blue = 0x5F9EA0, // rgb(95,158,160) + chartreuse = 0x7FFF00, // rgb(127,255,0) + chocolate = 0xD2691E, // rgb(210,105,30) + coral = 0xFF7F50, // rgb(255,127,80) + cornflower_blue = 0x6495ED, // rgb(100,149,237) + cornsilk = 0xFFF8DC, // rgb(255,248,220) + crimson = 0xDC143C, // rgb(220,20,60) + cyan = 0x00FFFF, // rgb(0,255,255) + dark_blue = 0x00008B, // rgb(0,0,139) + dark_cyan = 0x008B8B, // rgb(0,139,139) + dark_golden_rod = 0xB8860B, // rgb(184,134,11) + dark_gray = 0xA9A9A9, // rgb(169,169,169) + dark_green = 0x006400, // rgb(0,100,0) + dark_khaki = 0xBDB76B, // rgb(189,183,107) + dark_magenta = 0x8B008B, // rgb(139,0,139) + dark_olive_green = 0x556B2F, // rgb(85,107,47) + dark_orange = 0xFF8C00, // rgb(255,140,0) + dark_orchid = 0x9932CC, // rgb(153,50,204) + dark_red = 0x8B0000, // rgb(139,0,0) + dark_salmon = 0xE9967A, // rgb(233,150,122) + dark_sea_green = 0x8FBC8F, // rgb(143,188,143) + dark_slate_blue = 0x483D8B, // rgb(72,61,139) + dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) + dark_turquoise = 0x00CED1, // rgb(0,206,209) + dark_violet = 0x9400D3, // rgb(148,0,211) + deep_pink = 0xFF1493, // rgb(255,20,147) + deep_sky_blue = 0x00BFFF, // rgb(0,191,255) + dim_gray = 0x696969, // rgb(105,105,105) + dodger_blue = 0x1E90FF, // rgb(30,144,255) + fire_brick = 0xB22222, // rgb(178,34,34) + floral_white = 0xFFFAF0, // rgb(255,250,240) + forest_green = 0x228B22, // rgb(34,139,34) + fuchsia = 0xFF00FF, // rgb(255,0,255) + gainsboro = 0xDCDCDC, // rgb(220,220,220) + ghost_white = 0xF8F8FF, // rgb(248,248,255) + gold = 0xFFD700, // rgb(255,215,0) + golden_rod = 0xDAA520, // rgb(218,165,32) + gray = 0x808080, // rgb(128,128,128) + green = 0x008000, // rgb(0,128,0) + green_yellow = 0xADFF2F, // rgb(173,255,47) + honey_dew = 0xF0FFF0, // rgb(240,255,240) + hot_pink = 0xFF69B4, // rgb(255,105,180) + indian_red = 0xCD5C5C, // rgb(205,92,92) + indigo = 0x4B0082, // rgb(75,0,130) + ivory = 0xFFFFF0, // rgb(255,255,240) + khaki = 0xF0E68C, // rgb(240,230,140) + lavender = 0xE6E6FA, // rgb(230,230,250) + lavender_blush = 0xFFF0F5, // rgb(255,240,245) + lawn_green = 0x7CFC00, // rgb(124,252,0) + lemon_chiffon = 0xFFFACD, // rgb(255,250,205) + light_blue = 0xADD8E6, // rgb(173,216,230) + light_coral = 0xF08080, // rgb(240,128,128) + light_cyan = 0xE0FFFF, // rgb(224,255,255) + light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) + light_gray = 0xD3D3D3, // rgb(211,211,211) + light_green = 0x90EE90, // rgb(144,238,144) + light_pink = 0xFFB6C1, // rgb(255,182,193) + light_salmon = 0xFFA07A, // rgb(255,160,122) + light_sea_green = 0x20B2AA, // rgb(32,178,170) + light_sky_blue = 0x87CEFA, // rgb(135,206,250) + light_slate_gray = 0x778899, // rgb(119,136,153) + light_steel_blue = 0xB0C4DE, // rgb(176,196,222) + light_yellow = 0xFFFFE0, // rgb(255,255,224) + lime = 0x00FF00, // rgb(0,255,0) + lime_green = 0x32CD32, // rgb(50,205,50) + linen = 0xFAF0E6, // rgb(250,240,230) + magenta = 0xFF00FF, // rgb(255,0,255) + maroon = 0x800000, // rgb(128,0,0) + medium_aquamarine = 0x66CDAA, // rgb(102,205,170) + medium_blue = 0x0000CD, // rgb(0,0,205) + medium_orchid = 0xBA55D3, // rgb(186,85,211) + medium_purple = 0x9370DB, // rgb(147,112,219) + medium_sea_green = 0x3CB371, // rgb(60,179,113) + medium_slate_blue = 0x7B68EE, // rgb(123,104,238) + medium_spring_green = 0x00FA9A, // rgb(0,250,154) + medium_turquoise = 0x48D1CC, // rgb(72,209,204) + medium_violet_red = 0xC71585, // rgb(199,21,133) + midnight_blue = 0x191970, // rgb(25,25,112) + mint_cream = 0xF5FFFA, // rgb(245,255,250) + misty_rose = 0xFFE4E1, // rgb(255,228,225) + moccasin = 0xFFE4B5, // rgb(255,228,181) + navajo_white = 0xFFDEAD, // rgb(255,222,173) + navy = 0x000080, // rgb(0,0,128) + old_lace = 0xFDF5E6, // rgb(253,245,230) + olive = 0x808000, // rgb(128,128,0) + olive_drab = 0x6B8E23, // rgb(107,142,35) + orange = 0xFFA500, // rgb(255,165,0) + orange_red = 0xFF4500, // rgb(255,69,0) + orchid = 0xDA70D6, // rgb(218,112,214) + pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) + pale_green = 0x98FB98, // rgb(152,251,152) + pale_turquoise = 0xAFEEEE, // rgb(175,238,238) + pale_violet_red = 0xDB7093, // rgb(219,112,147) + papaya_whip = 0xFFEFD5, // rgb(255,239,213) + peach_puff = 0xFFDAB9, // rgb(255,218,185) + peru = 0xCD853F, // rgb(205,133,63) + pink = 0xFFC0CB, // rgb(255,192,203) + plum = 0xDDA0DD, // rgb(221,160,221) + powder_blue = 0xB0E0E6, // rgb(176,224,230) + purple = 0x800080, // rgb(128,0,128) + rebecca_purple = 0x663399, // rgb(102,51,153) + red = 0xFF0000, // rgb(255,0,0) + rosy_brown = 0xBC8F8F, // rgb(188,143,143) + royal_blue = 0x4169E1, // rgb(65,105,225) + saddle_brown = 0x8B4513, // rgb(139,69,19) + salmon = 0xFA8072, // rgb(250,128,114) + sandy_brown = 0xF4A460, // rgb(244,164,96) + sea_green = 0x2E8B57, // rgb(46,139,87) + sea_shell = 0xFFF5EE, // rgb(255,245,238) + sienna = 0xA0522D, // rgb(160,82,45) + silver = 0xC0C0C0, // rgb(192,192,192) + sky_blue = 0x87CEEB, // rgb(135,206,235) + slate_blue = 0x6A5ACD, // rgb(106,90,205) + slate_gray = 0x708090, // rgb(112,128,144) + snow = 0xFFFAFA, // rgb(255,250,250) + spring_green = 0x00FF7F, // rgb(0,255,127) + steel_blue = 0x4682B4, // rgb(70,130,180) + tan = 0xD2B48C, // rgb(210,180,140) + teal = 0x008080, // rgb(0,128,128) + thistle = 0xD8BFD8, // rgb(216,191,216) + tomato = 0xFF6347, // rgb(255,99,71) + turquoise = 0x40E0D0, // rgb(64,224,208) + violet = 0xEE82EE, // rgb(238,130,238) + wheat = 0xF5DEB3, // rgb(245,222,179) + white = 0xFFFFFF, // rgb(255,255,255) + white_smoke = 0xF5F5F5, // rgb(245,245,245) + yellow = 0xFFFF00, // rgb(255,255,0) + yellow_green = 0x9ACD32 // rgb(154,205,50) +}; // enum class color + +enum class terminal_color : uint8_t { + black = 30, + red, + green, + yellow, + blue, + magenta, + cyan, + white, + bright_black = 90, + bright_red, + bright_green, + bright_yellow, + bright_blue, + bright_magenta, + bright_cyan, + bright_white +}; + +enum class emphasis : uint8_t { + bold = 1, + faint = 1 << 1, + italic = 1 << 2, + underline = 1 << 3, + blink = 1 << 4, + reverse = 1 << 5, + conceal = 1 << 6, + strikethrough = 1 << 7, +}; + +// rgb is a struct for red, green and blue colors. +// Using the name "rgb" makes some editors show the color in a tooltip. +struct rgb { + FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {} + FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} + FMT_CONSTEXPR rgb(uint32_t hex) + : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} + FMT_CONSTEXPR rgb(color hex) + : r((uint32_t(hex) >> 16) & 0xFF), + g((uint32_t(hex) >> 8) & 0xFF), + b(uint32_t(hex) & 0xFF) {} + uint8_t r; + uint8_t g; + uint8_t b; +}; + +FMT_BEGIN_DETAIL_NAMESPACE + +// color is a struct of either a rgb color or a terminal color. +struct color_type { + FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {} + FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} { + value.rgb_color = static_cast(rgb_color); + } + FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} { + value.rgb_color = (static_cast(rgb_color.r) << 16) | + (static_cast(rgb_color.g) << 8) | rgb_color.b; + } + FMT_CONSTEXPR color_type(terminal_color term_color) noexcept + : is_rgb(), value{} { + value.term_color = static_cast(term_color); + } + bool is_rgb; + union color_union { + uint8_t term_color; + uint32_t rgb_color; + } value; +}; + +FMT_END_DETAIL_NAMESPACE + +/** A text style consisting of foreground and background colors and emphasis. */ +class text_style { + public: + FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept + : set_foreground_color(), set_background_color(), ems(em) {} + + FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) { + if (!set_foreground_color) { + set_foreground_color = rhs.set_foreground_color; + foreground_color = rhs.foreground_color; + } else if (rhs.set_foreground_color) { + if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb) + FMT_THROW(format_error("can't OR a terminal color")); + foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color; + } + + if (!set_background_color) { + set_background_color = rhs.set_background_color; + background_color = rhs.background_color; + } else if (rhs.set_background_color) { + if (!background_color.is_rgb || !rhs.background_color.is_rgb) + FMT_THROW(format_error("can't OR a terminal color")); + background_color.value.rgb_color |= rhs.background_color.value.rgb_color; + } + + ems = static_cast(static_cast(ems) | + static_cast(rhs.ems)); + return *this; + } + + friend FMT_CONSTEXPR text_style operator|(text_style lhs, + const text_style& rhs) { + return lhs |= rhs; + } + + FMT_CONSTEXPR bool has_foreground() const noexcept { + return set_foreground_color; + } + FMT_CONSTEXPR bool has_background() const noexcept { + return set_background_color; + } + FMT_CONSTEXPR bool has_emphasis() const noexcept { + return static_cast(ems) != 0; + } + FMT_CONSTEXPR detail::color_type get_foreground() const noexcept { + FMT_ASSERT(has_foreground(), "no foreground specified for this style"); + return foreground_color; + } + FMT_CONSTEXPR detail::color_type get_background() const noexcept { + FMT_ASSERT(has_background(), "no background specified for this style"); + return background_color; + } + FMT_CONSTEXPR emphasis get_emphasis() const noexcept { + FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); + return ems; + } + + private: + FMT_CONSTEXPR text_style(bool is_foreground, + detail::color_type text_color) noexcept + : set_foreground_color(), set_background_color(), ems() { + if (is_foreground) { + foreground_color = text_color; + set_foreground_color = true; + } else { + background_color = text_color; + set_background_color = true; + } + } + + friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept; + + friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept; + + detail::color_type foreground_color; + detail::color_type background_color; + bool set_foreground_color; + bool set_background_color; + emphasis ems; +}; + +/** Creates a text style from the foreground (text) color. */ +FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept { + return text_style(true, foreground); +} + +/** Creates a text style from the background color. */ +FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept { + return text_style(false, background); +} + +FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept { + return text_style(lhs) | rhs; +} + +FMT_BEGIN_DETAIL_NAMESPACE + +template struct ansi_color_escape { + FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color, + const char* esc) noexcept { + // If we have a terminal color, we need to output another escape code + // sequence. + if (!text_color.is_rgb) { + bool is_background = esc == string_view("\x1b[48;2;"); + uint32_t value = text_color.value.term_color; + // Background ASCII codes are the same as the foreground ones but with + // 10 more. + if (is_background) value += 10u; + + size_t index = 0; + buffer[index++] = static_cast('\x1b'); + buffer[index++] = static_cast('['); + + if (value >= 100u) { + buffer[index++] = static_cast('1'); + value %= 100u; + } + buffer[index++] = static_cast('0' + value / 10u); + buffer[index++] = static_cast('0' + value % 10u); + + buffer[index++] = static_cast('m'); + buffer[index++] = static_cast('\0'); + return; + } + + for (int i = 0; i < 7; i++) { + buffer[i] = static_cast(esc[i]); + } + rgb color(text_color.value.rgb_color); + to_esc(color.r, buffer + 7, ';'); + to_esc(color.g, buffer + 11, ';'); + to_esc(color.b, buffer + 15, 'm'); + buffer[19] = static_cast(0); + } + FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept { + uint8_t em_codes[num_emphases] = {}; + if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1; + if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2; + if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3; + if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4; + if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5; + if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7; + if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8; + if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9; + + size_t index = 0; + for (size_t i = 0; i < num_emphases; ++i) { + if (!em_codes[i]) continue; + buffer[index++] = static_cast('\x1b'); + buffer[index++] = static_cast('['); + buffer[index++] = static_cast('0' + em_codes[i]); + buffer[index++] = static_cast('m'); + } + buffer[index++] = static_cast(0); + } + FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } + + FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; } + FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept { + return buffer + std::char_traits::length(buffer); + } + + private: + static constexpr size_t num_emphases = 8; + Char buffer[7u + 3u * num_emphases + 1u]; + + static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, + char delimiter) noexcept { + out[0] = static_cast('0' + c / 100); + out[1] = static_cast('0' + c / 10 % 10); + out[2] = static_cast('0' + c % 10); + out[3] = static_cast(delimiter); + } + static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept { + return static_cast(em) & static_cast(mask); + } +}; + +template +FMT_CONSTEXPR ansi_color_escape make_foreground_color( + detail::color_type foreground) noexcept { + return ansi_color_escape(foreground, "\x1b[38;2;"); +} + +template +FMT_CONSTEXPR ansi_color_escape make_background_color( + detail::color_type background) noexcept { + return ansi_color_escape(background, "\x1b[48;2;"); +} + +template +FMT_CONSTEXPR ansi_color_escape make_emphasis(emphasis em) noexcept { + return ansi_color_escape(em); +} + +template inline void reset_color(buffer& buffer) { + auto reset_color = string_view("\x1b[0m"); + buffer.append(reset_color.begin(), reset_color.end()); +} + +template struct styled_arg { + const T& value; + text_style style; +}; + +template +void vformat_to(buffer& buf, const text_style& ts, + basic_string_view format_str, + basic_format_args>> args) { + bool has_style = false; + if (ts.has_emphasis()) { + has_style = true; + auto emphasis = detail::make_emphasis(ts.get_emphasis()); + buf.append(emphasis.begin(), emphasis.end()); + } + if (ts.has_foreground()) { + has_style = true; + auto foreground = detail::make_foreground_color(ts.get_foreground()); + buf.append(foreground.begin(), foreground.end()); + } + if (ts.has_background()) { + has_style = true; + auto background = detail::make_background_color(ts.get_background()); + buf.append(background.begin(), background.end()); + } + detail::vformat_to(buf, format_str, args, {}); + if (has_style) detail::reset_color(buf); +} + +FMT_END_DETAIL_NAMESPACE + +inline void vprint(std::FILE* f, const text_style& ts, string_view fmt, + format_args args) { + // Legacy wide streams are not supported. + auto buf = memory_buffer(); + detail::vformat_to(buf, ts, fmt, args); + if (detail::is_utf8()) { + detail::print(f, string_view(buf.begin(), buf.size())); + return; + } + buf.push_back('\0'); + int result = std::fputs(buf.data(), f); + if (result < 0) + FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); +} + +/** + \rst + Formats a string and prints it to the specified file stream using ANSI + escape sequences to specify text formatting. + + **Example**:: + + fmt::print(fmt::emphasis::bold | fg(fmt::color::red), + "Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +template ::value)> +void print(std::FILE* f, const text_style& ts, const S& format_str, + const Args&... args) { + vprint(f, ts, format_str, + fmt::make_format_args>>(args...)); +} + +/** + \rst + Formats a string and prints it to stdout using ANSI escape sequences to + specify text formatting. + + **Example**:: + + fmt::print(fmt::emphasis::bold | fg(fmt::color::red), + "Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +template ::value)> +void print(const text_style& ts, const S& format_str, const Args&... args) { + return print(stdout, ts, format_str, args...); +} + +template > +inline std::basic_string vformat( + const text_style& ts, const S& format_str, + basic_format_args>> args) { + basic_memory_buffer buf; + detail::vformat_to(buf, ts, detail::to_string_view(format_str), args); + return fmt::to_string(buf); +} + +/** + \rst + Formats arguments and returns the result as a string using ANSI + escape sequences to specify text formatting. + + **Example**:: + + #include + std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), + "The answer is {}", 42); + \endrst +*/ +template > +inline std::basic_string format(const text_style& ts, const S& format_str, + const Args&... args) { + return fmt::vformat(ts, detail::to_string_view(format_str), + fmt::make_format_args>(args...)); +} + +/** + Formats a string with the given text_style and writes the output to ``out``. + */ +template ::value)> +OutputIt vformat_to( + OutputIt out, const text_style& ts, basic_string_view format_str, + basic_format_args>> args) { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, ts, format_str, args); + return detail::get_iterator(buf, out); +} + +/** + \rst + Formats arguments with the given text_style, writes the result to the output + iterator ``out`` and returns the iterator past the end of the output range. + + **Example**:: + + std::vector out; + fmt::format_to(std::back_inserter(out), + fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); + \endrst +*/ +template >::value&& + detail::is_string::value> +inline auto format_to(OutputIt out, const text_style& ts, const S& format_str, + Args&&... args) -> + typename std::enable_if::type { + return vformat_to(out, ts, detail::to_string_view(format_str), + fmt::make_format_args>>(args...)); +} + +template +struct formatter, Char> : formatter { + template + auto format(const detail::styled_arg& arg, FormatContext& ctx) const + -> decltype(ctx.out()) { + const auto& ts = arg.style; + const auto& value = arg.value; + auto out = ctx.out(); + + bool has_style = false; + if (ts.has_emphasis()) { + has_style = true; + auto emphasis = detail::make_emphasis(ts.get_emphasis()); + out = std::copy(emphasis.begin(), emphasis.end(), out); + } + if (ts.has_foreground()) { + has_style = true; + auto foreground = + detail::make_foreground_color(ts.get_foreground()); + out = std::copy(foreground.begin(), foreground.end(), out); + } + if (ts.has_background()) { + has_style = true; + auto background = + detail::make_background_color(ts.get_background()); + out = std::copy(background.begin(), background.end(), out); + } + out = formatter::format(value, ctx); + if (has_style) { + auto reset_color = string_view("\x1b[0m"); + out = std::copy(reset_color.begin(), reset_color.end(), out); + } + return out; + } +}; + +/** + \rst + Returns an argument that will be formatted using ANSI escape sequences, + to be used in a formatting function. + + **Example**:: + + fmt::print("Elapsed time: {0:.2f} seconds", + fmt::styled(1.23, fmt::fg(fmt::color::green) | + fmt::bg(fmt::color::blue))); + \endrst + */ +template +FMT_CONSTEXPR auto styled(const T& value, text_style ts) + -> detail::styled_arg> { + return detail::styled_arg>{value, ts}; +} + +FMT_END_EXPORT +FMT_END_NAMESPACE + +#endif // FMT_COLOR_H_ diff --git a/include/fmt/compile.h b/include/fmt/compile.h new file mode 100644 index 0000000..94e13c0 --- /dev/null +++ b/include/fmt/compile.h @@ -0,0 +1,607 @@ +// Formatting library for C++ - experimental format string compilation +// +// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_COMPILE_H_ +#define FMT_COMPILE_H_ + +#include "format.h" + +FMT_BEGIN_NAMESPACE +namespace detail { + +template +FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end, + counting_iterator it) { + return it + (end - begin); +} + +template class truncating_iterator_base { + protected: + OutputIt out_; + size_t limit_; + size_t count_ = 0; + + truncating_iterator_base() : out_(), limit_(0) {} + + truncating_iterator_base(OutputIt out, size_t limit) + : out_(out), limit_(limit) {} + + public: + using iterator_category = std::output_iterator_tag; + using value_type = typename std::iterator_traits::value_type; + using difference_type = std::ptrdiff_t; + using pointer = void; + using reference = void; + FMT_UNCHECKED_ITERATOR(truncating_iterator_base); + + OutputIt base() const { return out_; } + size_t count() const { return count_; } +}; + +// An output iterator that truncates the output and counts the number of objects +// written to it. +template ::value_type>::type> +class truncating_iterator; + +template +class truncating_iterator + : public truncating_iterator_base { + mutable typename truncating_iterator_base::value_type blackhole_; + + public: + using value_type = typename truncating_iterator_base::value_type; + + truncating_iterator() = default; + + truncating_iterator(OutputIt out, size_t limit) + : truncating_iterator_base(out, limit) {} + + truncating_iterator& operator++() { + if (this->count_++ < this->limit_) ++this->out_; + return *this; + } + + truncating_iterator operator++(int) { + auto it = *this; + ++*this; + return it; + } + + value_type& operator*() const { + return this->count_ < this->limit_ ? *this->out_ : blackhole_; + } +}; + +template +class truncating_iterator + : public truncating_iterator_base { + public: + truncating_iterator() = default; + + truncating_iterator(OutputIt out, size_t limit) + : truncating_iterator_base(out, limit) {} + + template truncating_iterator& operator=(T val) { + if (this->count_++ < this->limit_) *this->out_++ = val; + return *this; + } + + truncating_iterator& operator++() { return *this; } + truncating_iterator& operator++(int) { return *this; } + truncating_iterator& operator*() { return *this; } +}; + +// A compile-time string which is compiled into fast formatting code. +class compiled_string {}; + +template +struct is_compiled_string : std::is_base_of {}; + +/** + \rst + Converts a string literal *s* into a format string that will be parsed at + compile time and converted into efficient formatting code. Requires C++17 + ``constexpr if`` compiler support. + + **Example**:: + + // Converts 42 into std::string using the most efficient method and no + // runtime format string processing. + std::string s = fmt::format(FMT_COMPILE("{}"), 42); + \endrst + */ +#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) +# define FMT_COMPILE(s) \ + FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit) +#else +# define FMT_COMPILE(s) FMT_STRING(s) +#endif + +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +template Str> +struct udl_compiled_string : compiled_string { + using char_type = Char; + explicit constexpr operator basic_string_view() const { + return {Str.data, N - 1}; + } +}; +#endif + +template +const T& first(const T& value, const Tail&...) { + return value; +} + +#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) +template struct type_list {}; + +// Returns a reference to the argument at index N from [first, rest...]. +template +constexpr const auto& get([[maybe_unused]] const T& first, + [[maybe_unused]] const Args&... rest) { + static_assert(N < 1 + sizeof...(Args), "index is out of bounds"); + if constexpr (N == 0) + return first; + else + return detail::get(rest...); +} + +template +constexpr int get_arg_index_by_name(basic_string_view name, + type_list) { + return get_arg_index_by_name(name); +} + +template struct get_type_impl; + +template struct get_type_impl> { + using type = + remove_cvref_t(std::declval()...))>; +}; + +template +using get_type = typename get_type_impl::type; + +template struct is_compiled_format : std::false_type {}; + +template struct text { + basic_string_view data; + using char_type = Char; + + template + constexpr OutputIt format(OutputIt out, const Args&...) const { + return write(out, data); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +template +constexpr text make_text(basic_string_view s, size_t pos, + size_t size) { + return {{&s[pos], size}}; +} + +template struct code_unit { + Char value; + using char_type = Char; + + template + constexpr OutputIt format(OutputIt out, const Args&...) const { + return write(out, value); + } +}; + +// This ensures that the argument type is convertible to `const T&`. +template +constexpr const T& get_arg_checked(const Args&... args) { + const auto& arg = detail::get(args...); + if constexpr (detail::is_named_arg>()) { + return arg.value; + } else { + return arg; + } +} + +template +struct is_compiled_format> : std::true_type {}; + +// A replacement field that refers to argument N. +template struct field { + using char_type = Char; + + template + constexpr OutputIt format(OutputIt out, const Args&... args) const { + return write(out, get_arg_checked(args...)); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +// A replacement field that refers to argument with name. +template struct runtime_named_field { + using char_type = Char; + basic_string_view name; + + template + constexpr static bool try_format_argument( + OutputIt& out, + // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9 + [[maybe_unused]] basic_string_view arg_name, const T& arg) { + if constexpr (is_named_arg::type>::value) { + if (arg_name == arg.name) { + out = write(out, arg.value); + return true; + } + } + return false; + } + + template + constexpr OutputIt format(OutputIt out, const Args&... args) const { + bool found = (try_format_argument(out, name, args) || ...); + if (!found) { + FMT_THROW(format_error("argument with specified name is not found")); + } + return out; + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +// A replacement field that refers to argument N and has format specifiers. +template struct spec_field { + using char_type = Char; + formatter fmt; + + template + constexpr FMT_INLINE OutputIt format(OutputIt out, + const Args&... args) const { + const auto& vargs = + fmt::make_format_args>(args...); + basic_format_context ctx(out, vargs); + return fmt.format(get_arg_checked(args...), ctx); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +template struct concat { + L lhs; + R rhs; + using char_type = typename L::char_type; + + template + constexpr OutputIt format(OutputIt out, const Args&... args) const { + out = lhs.format(out, args...); + return rhs.format(out, args...); + } +}; + +template +struct is_compiled_format> : std::true_type {}; + +template +constexpr concat make_concat(L lhs, R rhs) { + return {lhs, rhs}; +} + +struct unknown_format {}; + +template +constexpr size_t parse_text(basic_string_view str, size_t pos) { + for (size_t size = str.size(); pos != size; ++pos) { + if (str[pos] == '{' || str[pos] == '}') break; + } + return pos; +} + +template +constexpr auto compile_format_string(S format_str); + +template +constexpr auto parse_tail(T head, S format_str) { + if constexpr (POS != + basic_string_view(format_str).size()) { + constexpr auto tail = compile_format_string(format_str); + if constexpr (std::is_same, + unknown_format>()) + return tail; + else + return make_concat(head, tail); + } else { + return head; + } +} + +template struct parse_specs_result { + formatter fmt; + size_t end; + int next_arg_id; +}; + +enum { manual_indexing_id = -1 }; + +template +constexpr parse_specs_result parse_specs(basic_string_view str, + size_t pos, int next_arg_id) { + str.remove_prefix(pos); + auto ctx = + compile_parse_context(str, max_value(), nullptr, next_arg_id); + auto f = formatter(); + auto end = f.parse(ctx); + return {f, pos + fmt::detail::to_unsigned(end - str.data()), + next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()}; +} + +template struct arg_id_handler { + arg_ref arg_id; + + constexpr int on_auto() { + FMT_ASSERT(false, "handler cannot be used with automatic indexing"); + return 0; + } + constexpr int on_index(int id) { + arg_id = arg_ref(id); + return 0; + } + constexpr int on_name(basic_string_view id) { + arg_id = arg_ref(id); + return 0; + } +}; + +template struct parse_arg_id_result { + arg_ref arg_id; + const Char* arg_id_end; +}; + +template +constexpr auto parse_arg_id(const Char* begin, const Char* end) { + auto handler = arg_id_handler{arg_ref{}}; + auto arg_id_end = parse_arg_id(begin, end, handler); + return parse_arg_id_result{handler.arg_id, arg_id_end}; +} + +template struct field_type { + using type = remove_cvref_t; +}; + +template +struct field_type::value>> { + using type = remove_cvref_t; +}; + +template +constexpr auto parse_replacement_field_then_tail(S format_str) { + using char_type = typename S::char_type; + constexpr auto str = basic_string_view(format_str); + constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); + if constexpr (c == '}') { + return parse_tail( + field::type, ARG_INDEX>(), + format_str); + } else if constexpr (c != ':') { + FMT_THROW(format_error("expected ':'")); + } else { + constexpr auto result = parse_specs::type>( + str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID); + if constexpr (result.end >= str.size() || str[result.end] != '}') { + FMT_THROW(format_error("expected '}'")); + return 0; + } else { + return parse_tail( + spec_field::type, ARG_INDEX>{ + result.fmt}, + format_str); + } + } +} + +// Compiles a non-empty format string and returns the compiled representation +// or unknown_format() on unrecognized input. +template +constexpr auto compile_format_string(S format_str) { + using char_type = typename S::char_type; + constexpr auto str = basic_string_view(format_str); + if constexpr (str[POS] == '{') { + if constexpr (POS + 1 == str.size()) + FMT_THROW(format_error("unmatched '{' in format string")); + if constexpr (str[POS + 1] == '{') { + return parse_tail(make_text(str, POS, 1), format_str); + } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { + static_assert(ID != manual_indexing_id, + "cannot switch from manual to automatic argument indexing"); + constexpr auto next_id = + ID != manual_indexing_id ? ID + 1 : manual_indexing_id; + return parse_replacement_field_then_tail, Args, + POS + 1, ID, next_id>( + format_str); + } else { + constexpr auto arg_id_result = + parse_arg_id(str.data() + POS + 1, str.data() + str.size()); + constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data(); + constexpr char_type c = + arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); + static_assert(c == '}' || c == ':', "missing '}' in format string"); + if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) { + static_assert( + ID == manual_indexing_id || ID == 0, + "cannot switch from automatic to manual argument indexing"); + constexpr auto arg_index = arg_id_result.arg_id.val.index; + return parse_replacement_field_then_tail, + Args, arg_id_end_pos, + arg_index, manual_indexing_id>( + format_str); + } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) { + constexpr auto arg_index = + get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{}); + if constexpr (arg_index != invalid_arg_index) { + constexpr auto next_id = + ID != manual_indexing_id ? ID + 1 : manual_indexing_id; + return parse_replacement_field_then_tail< + decltype(get_type::value), Args, arg_id_end_pos, + arg_index, next_id>(format_str); + } else { + if constexpr (c == '}') { + return parse_tail( + runtime_named_field{arg_id_result.arg_id.val.name}, + format_str); + } else if constexpr (c == ':') { + return unknown_format(); // no type info for specs parsing + } + } + } + } + } else if constexpr (str[POS] == '}') { + if constexpr (POS + 1 == str.size()) + FMT_THROW(format_error("unmatched '}' in format string")); + return parse_tail(make_text(str, POS, 1), format_str); + } else { + constexpr auto end = parse_text(str, POS + 1); + if constexpr (end - POS > 1) { + return parse_tail(make_text(str, POS, end - POS), + format_str); + } else { + return parse_tail(code_unit{str[POS]}, + format_str); + } + } +} + +template ::value)> +constexpr auto compile(S format_str) { + constexpr auto str = basic_string_view(format_str); + if constexpr (str.size() == 0) { + return detail::make_text(str, 0, 0); + } else { + constexpr auto result = + detail::compile_format_string, 0, 0>( + format_str); + return result; + } +} +#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) +} // namespace detail + +FMT_BEGIN_EXPORT + +#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) + +template ::value)> +FMT_INLINE std::basic_string format(const CompiledFormat& cf, + const Args&... args) { + auto s = std::basic_string(); + cf.format(std::back_inserter(s), args...); + return s; +} + +template ::value)> +constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf, + const Args&... args) { + return cf.format(out, args...); +} + +template ::value)> +FMT_INLINE std::basic_string format(const S&, + Args&&... args) { + if constexpr (std::is_same::value) { + constexpr auto str = basic_string_view(S()); + if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') { + const auto& first = detail::first(args...); + if constexpr (detail::is_named_arg< + remove_cvref_t>::value) { + return fmt::to_string(first.value); + } else { + return fmt::to_string(first); + } + } + } + constexpr auto compiled = detail::compile(S()); + if constexpr (std::is_same, + detail::unknown_format>()) { + return fmt::format( + static_cast>(S()), + std::forward(args)...); + } else { + return fmt::format(compiled, std::forward(args)...); + } +} + +template ::value)> +FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) { + constexpr auto compiled = detail::compile(S()); + if constexpr (std::is_same, + detail::unknown_format>()) { + return fmt::format_to( + out, static_cast>(S()), + std::forward(args)...); + } else { + return fmt::format_to(out, compiled, std::forward(args)...); + } +} +#endif + +template ::value)> +format_to_n_result format_to_n(OutputIt out, size_t n, + const S& format_str, Args&&... args) { + auto it = fmt::format_to(detail::truncating_iterator(out, n), + format_str, std::forward(args)...); + return {it.base(), it.count()}; +} + +template ::value)> +FMT_CONSTEXPR20 size_t formatted_size(const S& format_str, + const Args&... args) { + return fmt::format_to(detail::counting_iterator(), format_str, args...) + .count(); +} + +template ::value)> +void print(std::FILE* f, const S& format_str, const Args&... args) { + memory_buffer buffer; + fmt::format_to(std::back_inserter(buffer), format_str, args...); + detail::print(f, {buffer.data(), buffer.size()}); +} + +template ::value)> +void print(const S& format_str, const Args&... args) { + print(stdout, format_str, args...); +} + +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +inline namespace literals { +template constexpr auto operator""_cf() { + using char_t = remove_cvref_t; + return detail::udl_compiled_string(); +} +} // namespace literals +#endif + +FMT_END_EXPORT +FMT_END_NAMESPACE + +#endif // FMT_COMPILE_H_ diff --git a/include/fmt/core.h b/include/fmt/core.h new file mode 100644 index 0000000..8848939 --- /dev/null +++ b/include/fmt/core.h @@ -0,0 +1,2920 @@ +// Formatting library for C++ - the core API for char/UTF-8 +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_CORE_H_ +#define FMT_CORE_H_ + +#include // std::byte +#include // std::FILE +#include // std::strlen +#include +#include +#include +#include + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 100001 + +#if defined(__clang__) && !defined(__ibmxl__) +# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#else +# define FMT_CLANG_VERSION 0 +#endif + +#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \ + !defined(__NVCOMPILER) +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#else +# define FMT_GCC_VERSION 0 +#endif + +#ifndef FMT_GCC_PRAGMA +// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884. +# if FMT_GCC_VERSION >= 504 +# define FMT_GCC_PRAGMA(arg) _Pragma(arg) +# else +# define FMT_GCC_PRAGMA(arg) +# endif +#endif + +#ifdef __ICL +# define FMT_ICC_VERSION __ICL +#elif defined(__INTEL_COMPILER) +# define FMT_ICC_VERSION __INTEL_COMPILER +#else +# define FMT_ICC_VERSION 0 +#endif + +#ifdef _MSC_VER +# define FMT_MSC_VERSION _MSC_VER +# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) +#else +# define FMT_MSC_VERSION 0 +# define FMT_MSC_WARNING(...) +#endif + +#ifdef _MSVC_LANG +# define FMT_CPLUSPLUS _MSVC_LANG +#else +# define FMT_CPLUSPLUS __cplusplus +#endif + +#ifdef __has_feature +# define FMT_HAS_FEATURE(x) __has_feature(x) +#else +# define FMT_HAS_FEATURE(x) 0 +#endif + +#if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900 +# define FMT_HAS_INCLUDE(x) __has_include(x) +#else +# define FMT_HAS_INCLUDE(x) 0 +#endif + +#ifdef __has_cpp_attribute +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + +#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) + +#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ + (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) + +// Check if relaxed C++14 constexpr is supported. +// GCC doesn't allow throw in constexpr until version 6 (bug 67371). +#ifndef FMT_USE_CONSTEXPR +# if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \ + (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) && \ + !FMT_ICC_VERSION && !defined(__NVCC__) +# define FMT_USE_CONSTEXPR 1 +# else +# define FMT_USE_CONSTEXPR 0 +# endif +#endif +#if FMT_USE_CONSTEXPR +# define FMT_CONSTEXPR constexpr +#else +# define FMT_CONSTEXPR +#endif + +#if ((FMT_CPLUSPLUS >= 202002L) && \ + (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \ + (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002) +# define FMT_CONSTEXPR20 constexpr +#else +# define FMT_CONSTEXPR20 +#endif + +// Check if constexpr std::char_traits<>::{compare,length} are supported. +#if defined(__GLIBCXX__) +# if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \ + _GLIBCXX_RELEASE >= 7 // GCC 7+ libstdc++ has _GLIBCXX_RELEASE. +# define FMT_CONSTEXPR_CHAR_TRAITS constexpr +# endif +#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \ + _LIBCPP_VERSION >= 4000 +# define FMT_CONSTEXPR_CHAR_TRAITS constexpr +#elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L +# define FMT_CONSTEXPR_CHAR_TRAITS constexpr +#endif +#ifndef FMT_CONSTEXPR_CHAR_TRAITS +# define FMT_CONSTEXPR_CHAR_TRAITS +#endif + +// Check if exceptions are disabled. +#ifndef FMT_EXCEPTIONS +# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ + (FMT_MSC_VERSION && !_HAS_EXCEPTIONS) +# define FMT_EXCEPTIONS 0 +# else +# define FMT_EXCEPTIONS 1 +# endif +#endif + +// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. +#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \ + !defined(__NVCC__) +# define FMT_NORETURN [[noreturn]] +#else +# define FMT_NORETURN +#endif + +#ifndef FMT_NODISCARD +# if FMT_HAS_CPP17_ATTRIBUTE(nodiscard) +# define FMT_NODISCARD [[nodiscard]] +# else +# define FMT_NODISCARD +# endif +#endif + +#ifndef FMT_INLINE +# if FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_INLINE inline __attribute__((always_inline)) +# else +# define FMT_INLINE inline +# endif +#endif + +#ifdef _MSC_VER +# define FMT_UNCHECKED_ITERATOR(It) \ + using _Unchecked_type = It // Mark iterator as checked. +#else +# define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It +#endif + +#ifndef FMT_BEGIN_NAMESPACE +# define FMT_BEGIN_NAMESPACE \ + namespace fmt { \ + inline namespace v10 { +# define FMT_END_NAMESPACE \ + } \ + } +#endif + +#ifndef FMT_EXPORT +# define FMT_EXPORT +# define FMT_BEGIN_EXPORT +# define FMT_END_EXPORT +#endif + +#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +# ifdef FMT_LIB_EXPORT +# define FMT_API __declspec(dllexport) +# elif defined(FMT_SHARED) +# define FMT_API __declspec(dllimport) +# endif +#else +# if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) +# if defined(__GNUC__) || defined(__clang__) +# define FMT_API __attribute__((visibility("default"))) +# endif +# endif +#endif +#ifndef FMT_API +# define FMT_API +#endif + +// libc++ supports string_view in pre-c++17. +#if FMT_HAS_INCLUDE() && \ + (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) +# include +# define FMT_USE_STRING_VIEW +#elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L +# include +# define FMT_USE_EXPERIMENTAL_STRING_VIEW +#endif + +#ifndef FMT_UNICODE +# define FMT_UNICODE !FMT_MSC_VERSION +#endif + +#ifndef FMT_CONSTEVAL +# if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \ + (!defined(__apple_build_version__) || \ + __apple_build_version__ >= 14000029L) && \ + FMT_CPLUSPLUS >= 202002L) || \ + (defined(__cpp_consteval) && \ + (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704)) +// consteval is broken in MSVC before VS2022 and Apple clang before 14. +# define FMT_CONSTEVAL consteval +# define FMT_HAS_CONSTEVAL +# else +# define FMT_CONSTEVAL +# endif +#endif + +#ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS +# if defined(__cpp_nontype_template_args) && \ + ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \ + __cpp_nontype_template_args >= 201911L) && \ + !defined(__NVCOMPILER) && !defined(__LCC__) +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 +# else +# define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 +# endif +#endif + +#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L +# define FMT_INLINE_VARIABLE inline +#else +# define FMT_INLINE_VARIABLE +#endif + +// Enable minimal optimizations for more compact code in debug mode. +FMT_GCC_PRAGMA("GCC push_options") +#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \ + !defined(__CUDACC__) +FMT_GCC_PRAGMA("GCC optimize(\"Og\")") +#endif + +FMT_BEGIN_NAMESPACE + +// Implementations of enable_if_t and other metafunctions for older systems. +template +using enable_if_t = typename std::enable_if::type; +template +using conditional_t = typename std::conditional::type; +template using bool_constant = std::integral_constant; +template +using remove_reference_t = typename std::remove_reference::type; +template +using remove_const_t = typename std::remove_const::type; +template +using remove_cvref_t = typename std::remove_cv>::type; +template struct type_identity { using type = T; }; +template using type_identity_t = typename type_identity::type; +template +using underlying_t = typename std::underlying_type::type; + +// Checks whether T is a container with contiguous storage. +template struct is_contiguous : std::false_type {}; +template +struct is_contiguous> : std::true_type {}; + +struct monostate { + constexpr monostate() {} +}; + +// An enable_if helper to be used in template parameters which results in much +// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed +// to workaround a bug in MSVC 2019 (see #1140 and #1186). +#ifdef FMT_DOC +# define FMT_ENABLE_IF(...) +#else +# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 +#endif + +// This is defined in core.h instead of format.h to avoid injecting in std. +#ifdef __cpp_lib_byte +inline auto format_as(std::byte b) -> unsigned char { + return static_cast(b); +} +#endif + +namespace detail { +// Suppresses "unused variable" warnings with the method described in +// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. +// (void)var does not work on many Intel compilers. +template FMT_CONSTEXPR void ignore_unused(const T&...) {} + +constexpr FMT_INLINE auto is_constant_evaluated( + bool default_value = false) noexcept -> bool { +// Workaround for incompatibility between libstdc++ consteval-based +// std::is_constant_evaluated() implementation and clang-14. +// https://github.com/fmtlib/fmt/issues/3247 +#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \ + _GLIBCXX_RELEASE >= 12 && \ + (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) + ignore_unused(default_value); + return __builtin_is_constant_evaluated(); +#elif defined(__cpp_lib_is_constant_evaluated) + ignore_unused(default_value); + return std::is_constant_evaluated(); +#else + return default_value; +#endif +} + +// Suppresses "conditional expression is constant" warnings. +template constexpr FMT_INLINE auto const_check(T value) -> T { + return value; +} + +FMT_NORETURN FMT_API void assert_fail(const char* file, int line, + const char* message); + +#ifndef FMT_ASSERT +# ifdef NDEBUG +// FMT_ASSERT is not empty to avoid -Wempty-body. +# define FMT_ASSERT(condition, message) \ + fmt::detail::ignore_unused((condition), (message)) +# else +# define FMT_ASSERT(condition, message) \ + ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ + ? (void)0 \ + : fmt::detail::assert_fail(__FILE__, __LINE__, (message))) +# endif +#endif + +#if defined(FMT_USE_STRING_VIEW) +template using std_string_view = std::basic_string_view; +#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) +template +using std_string_view = std::experimental::basic_string_view; +#else +template struct std_string_view {}; +#endif + +#ifdef FMT_USE_INT128 +// Do nothing. +#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ + !(FMT_CLANG_VERSION && FMT_MSC_VERSION) +# define FMT_USE_INT128 1 +using int128_opt = __int128_t; // An optional native 128-bit integer. +using uint128_opt = __uint128_t; +template inline auto convert_for_visit(T value) -> T { + return value; +} +#else +# define FMT_USE_INT128 0 +#endif +#if !FMT_USE_INT128 +enum class int128_opt {}; +enum class uint128_opt {}; +// Reduce template instantiations. +template auto convert_for_visit(T) -> monostate { return {}; } +#endif + +// Casts a nonnegative integer to unsigned. +template +FMT_CONSTEXPR auto to_unsigned(Int value) -> + typename std::make_unsigned::type { + FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); + return static_cast::type>(value); +} + +FMT_CONSTEXPR inline auto is_utf8() -> bool { + FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7"; + + // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297). + using uchar = unsigned char; + return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 && + uchar(section[1]) == 0xA7); +} +} // namespace detail + +/** + An implementation of ``std::basic_string_view`` for pre-C++17. It provides a + subset of the API. ``fmt::basic_string_view`` is used for format strings even + if ``std::string_view`` is available to prevent issues when a library is + compiled with a different ``-std`` option than the client code (which is not + recommended). + */ +FMT_EXPORT +template class basic_string_view { + private: + const Char* data_; + size_t size_; + + public: + using value_type = Char; + using iterator = const Char*; + + constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} + + /** Constructs a string reference object from a C string and a size. */ + constexpr basic_string_view(const Char* s, size_t count) noexcept + : data_(s), size_(count) {} + + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + FMT_CONSTEXPR_CHAR_TRAITS + FMT_INLINE + basic_string_view(const Char* s) + : data_(s), + size_(detail::const_check(std::is_same::value && + !detail::is_constant_evaluated(true)) + ? std::strlen(reinterpret_cast(s)) + : std::char_traits::length(s)) {} + + /** Constructs a string reference from a ``std::basic_string`` object. */ + template + FMT_CONSTEXPR basic_string_view( + const std::basic_string& s) noexcept + : data_(s.data()), size_(s.size()) {} + + template >::value)> + FMT_CONSTEXPR basic_string_view(S s) noexcept + : data_(s.data()), size_(s.size()) {} + + /** Returns a pointer to the string data. */ + constexpr auto data() const noexcept -> const Char* { return data_; } + + /** Returns the string size. */ + constexpr auto size() const noexcept -> size_t { return size_; } + + constexpr auto begin() const noexcept -> iterator { return data_; } + constexpr auto end() const noexcept -> iterator { return data_ + size_; } + + constexpr auto operator[](size_t pos) const noexcept -> const Char& { + return data_[pos]; + } + + FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { + data_ += n; + size_ -= n; + } + + FMT_CONSTEXPR_CHAR_TRAITS bool starts_with( + basic_string_view sv) const noexcept { + return size_ >= sv.size_ && + std::char_traits::compare(data_, sv.data_, sv.size_) == 0; + } + FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(Char c) const noexcept { + return size_ >= 1 && std::char_traits::eq(*data_, c); + } + FMT_CONSTEXPR_CHAR_TRAITS bool starts_with(const Char* s) const { + return starts_with(basic_string_view(s)); + } + + // Lexicographically compare this string reference to other. + FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int { + size_t str_size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, str_size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs, + basic_string_view rhs) + -> bool { + return lhs.compare(rhs) == 0; + } + friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) != 0; + } + friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) < 0; + } + friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) <= 0; + } + friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) > 0; + } + friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { + return lhs.compare(rhs) >= 0; + } +}; + +FMT_EXPORT +using string_view = basic_string_view; + +/** Specifies if ``T`` is a character type. Can be specialized by users. */ +FMT_EXPORT +template struct is_char : std::false_type {}; +template <> struct is_char : std::true_type {}; + +namespace detail { + +// A base class for compile-time strings. +struct compile_string {}; + +template +struct is_compile_string : std::is_base_of {}; + +template ::value)> +FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view { + return s; +} +template +inline auto to_string_view(const std::basic_string& s) + -> basic_string_view { + return s; +} +template +constexpr auto to_string_view(basic_string_view s) + -> basic_string_view { + return s; +} +template >::value)> +inline auto to_string_view(std_string_view s) -> basic_string_view { + return s; +} +template ::value)> +constexpr auto to_string_view(const S& s) + -> basic_string_view { + return basic_string_view(s); +} +void to_string_view(...); + +// Specifies whether S is a string type convertible to fmt::basic_string_view. +// It should be a constexpr function but MSVC 2017 fails to compile it in +// enable_if and MSVC 2015 fails to compile it as an alias template. +// ADL is intentionally disabled as to_string_view is not an extension point. +template +struct is_string + : std::is_class()))> {}; + +template struct char_t_impl {}; +template struct char_t_impl::value>> { + using result = decltype(to_string_view(std::declval())); + using type = typename result::value_type; +}; + +enum class type { + none_type, + // Integer types should go first, + int_type, + uint_type, + long_long_type, + ulong_long_type, + int128_type, + uint128_type, + bool_type, + char_type, + last_integer_type = char_type, + // followed by floating-point types. + float_type, + double_type, + long_double_type, + last_numeric_type = long_double_type, + cstring_type, + string_type, + pointer_type, + custom_type +}; + +// Maps core type T to the corresponding type enum constant. +template +struct type_constant : std::integral_constant {}; + +#define FMT_TYPE_CONSTANT(Type, constant) \ + template \ + struct type_constant \ + : std::integral_constant {} + +FMT_TYPE_CONSTANT(int, int_type); +FMT_TYPE_CONSTANT(unsigned, uint_type); +FMT_TYPE_CONSTANT(long long, long_long_type); +FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); +FMT_TYPE_CONSTANT(int128_opt, int128_type); +FMT_TYPE_CONSTANT(uint128_opt, uint128_type); +FMT_TYPE_CONSTANT(bool, bool_type); +FMT_TYPE_CONSTANT(Char, char_type); +FMT_TYPE_CONSTANT(float, float_type); +FMT_TYPE_CONSTANT(double, double_type); +FMT_TYPE_CONSTANT(long double, long_double_type); +FMT_TYPE_CONSTANT(const Char*, cstring_type); +FMT_TYPE_CONSTANT(basic_string_view, string_type); +FMT_TYPE_CONSTANT(const void*, pointer_type); + +constexpr bool is_integral_type(type t) { + return t > type::none_type && t <= type::last_integer_type; +} +constexpr bool is_arithmetic_type(type t) { + return t > type::none_type && t <= type::last_numeric_type; +} + +constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } +constexpr auto in(type t, int set) -> bool { + return ((set >> static_cast(t)) & 1) != 0; +} + +// Bitsets of types. +enum { + sint_set = + set(type::int_type) | set(type::long_long_type) | set(type::int128_type), + uint_set = set(type::uint_type) | set(type::ulong_long_type) | + set(type::uint128_type), + bool_set = set(type::bool_type), + char_set = set(type::char_type), + float_set = set(type::float_type) | set(type::double_type) | + set(type::long_double_type), + string_set = set(type::string_type), + cstring_set = set(type::cstring_type), + pointer_set = set(type::pointer_type) +}; + +FMT_NORETURN FMT_API void throw_format_error(const char* message); + +struct error_handler { + constexpr error_handler() = default; + + // This function is intentionally not constexpr to give a compile-time error. + FMT_NORETURN void on_error(const char* message) { + throw_format_error(message); + } +}; +} // namespace detail + +/** String's character type. */ +template using char_t = typename detail::char_t_impl::type; + +/** + \rst + Parsing context consisting of a format string range being parsed and an + argument counter for automatic indexing. + You can use the ``format_parse_context`` type alias for ``char`` instead. + \endrst + */ +FMT_EXPORT +template class basic_format_parse_context { + private: + basic_string_view format_str_; + int next_arg_id_; + + FMT_CONSTEXPR void do_check_arg_id(int id); + + public: + using char_type = Char; + using iterator = const Char*; + + explicit constexpr basic_format_parse_context( + basic_string_view format_str, int next_arg_id = 0) + : format_str_(format_str), next_arg_id_(next_arg_id) {} + + /** + Returns an iterator to the beginning of the format string range being + parsed. + */ + constexpr auto begin() const noexcept -> iterator { + return format_str_.begin(); + } + + /** + Returns an iterator past the end of the format string range being parsed. + */ + constexpr auto end() const noexcept -> iterator { return format_str_.end(); } + + /** Advances the begin iterator to ``it``. */ + FMT_CONSTEXPR void advance_to(iterator it) { + format_str_.remove_prefix(detail::to_unsigned(it - begin())); + } + + /** + Reports an error if using the manual argument indexing; otherwise returns + the next argument index and switches to the automatic indexing. + */ + FMT_CONSTEXPR auto next_arg_id() -> int { + if (next_arg_id_ < 0) { + detail::throw_format_error( + "cannot switch from manual to automatic argument indexing"); + return 0; + } + int id = next_arg_id_++; + do_check_arg_id(id); + return id; + } + + /** + Reports an error if using the automatic argument indexing; otherwise + switches to the manual indexing. + */ + FMT_CONSTEXPR void check_arg_id(int id) { + if (next_arg_id_ > 0) { + detail::throw_format_error( + "cannot switch from automatic to manual argument indexing"); + return; + } + next_arg_id_ = -1; + do_check_arg_id(id); + } + FMT_CONSTEXPR void check_arg_id(basic_string_view) {} + FMT_CONSTEXPR void check_dynamic_spec(int arg_id); +}; + +FMT_EXPORT +using format_parse_context = basic_format_parse_context; + +namespace detail { +// A parse context with extra data used only in compile-time checks. +template +class compile_parse_context : public basic_format_parse_context { + private: + int num_args_; + const type* types_; + using base = basic_format_parse_context; + + public: + explicit FMT_CONSTEXPR compile_parse_context( + basic_string_view format_str, int num_args, const type* types, + int next_arg_id = 0) + : base(format_str, next_arg_id), num_args_(num_args), types_(types) {} + + constexpr auto num_args() const -> int { return num_args_; } + constexpr auto arg_type(int id) const -> type { return types_[id]; } + + FMT_CONSTEXPR auto next_arg_id() -> int { + int id = base::next_arg_id(); + if (id >= num_args_) throw_format_error("argument not found"); + return id; + } + + FMT_CONSTEXPR void check_arg_id(int id) { + base::check_arg_id(id); + if (id >= num_args_) throw_format_error("argument not found"); + } + using base::check_arg_id; + + FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { + detail::ignore_unused(arg_id); +#if !defined(__LCC__) + if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) + throw_format_error("width/precision is not integer"); +#endif + } +}; + +// Extracts a reference to the container from back_insert_iterator. +template +inline auto get_container(std::back_insert_iterator it) + -> Container& { + using base = std::back_insert_iterator; + struct accessor : base { + accessor(base b) : base(b) {} + using base::container; + }; + return *accessor(it).container; +} + +template +FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out) + -> OutputIt { + while (begin != end) *out++ = static_cast(*begin++); + return out; +} + +template , U>::value&& is_char::value)> +FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* { + if (is_constant_evaluated()) return copy_str(begin, end, out); + auto size = to_unsigned(end - begin); + if (size > 0) memcpy(out, begin, size * sizeof(U)); + return out + size; +} + +/** + \rst + A contiguous memory buffer with an optional growing ability. It is an internal + class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`. + \endrst + */ +template class buffer { + private: + T* ptr_; + size_t size_; + size_t capacity_; + + protected: + // Don't initialize ptr_ since it is not accessed to save a few cycles. + FMT_MSC_WARNING(suppress : 26495) + buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {} + + FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept + : ptr_(p), size_(sz), capacity_(cap) {} + + FMT_CONSTEXPR20 ~buffer() = default; + buffer(buffer&&) = default; + + /** Sets the buffer data and capacity. */ + FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { + ptr_ = buf_data; + capacity_ = buf_capacity; + } + + /** Increases the buffer capacity to hold at least *capacity* elements. */ + virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0; + + public: + using value_type = T; + using const_reference = const T&; + + buffer(const buffer&) = delete; + void operator=(const buffer&) = delete; + + FMT_INLINE auto begin() noexcept -> T* { return ptr_; } + FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; } + + FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; } + FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; } + + /** Returns the size of this buffer. */ + constexpr auto size() const noexcept -> size_t { return size_; } + + /** Returns the capacity of this buffer. */ + constexpr auto capacity() const noexcept -> size_t { return capacity_; } + + /** Returns a pointer to the buffer data. */ + FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } + + /** Returns a pointer to the buffer data. */ + FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } + + /** Clears this buffer. */ + void clear() { size_ = 0; } + + // Tries resizing the buffer to contain *count* elements. If T is a POD type + // the new elements may not be initialized. + FMT_CONSTEXPR20 void try_resize(size_t count) { + try_reserve(count); + size_ = count <= capacity_ ? count : capacity_; + } + + // Tries increasing the buffer capacity to *new_capacity*. It can increase the + // capacity by a smaller amount than requested but guarantees there is space + // for at least one additional element either by increasing the capacity or by + // flushing the buffer if it is full. + FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) { + if (new_capacity > capacity_) grow(new_capacity); + } + + FMT_CONSTEXPR20 void push_back(const T& value) { + try_reserve(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template void append(const U* begin, const U* end); + + template FMT_CONSTEXPR auto operator[](Idx index) -> T& { + return ptr_[index]; + } + template + FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { + return ptr_[index]; + } +}; + +struct buffer_traits { + explicit buffer_traits(size_t) {} + auto count() const -> size_t { return 0; } + auto limit(size_t size) -> size_t { return size; } +}; + +class fixed_buffer_traits { + private: + size_t count_ = 0; + size_t limit_; + + public: + explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} + auto count() const -> size_t { return count_; } + auto limit(size_t size) -> size_t { + size_t n = limit_ > count_ ? limit_ - count_ : 0; + count_ += size; + return size < n ? size : n; + } +}; + +// A buffer that writes to an output iterator when flushed. +template +class iterator_buffer final : public Traits, public buffer { + private: + OutputIt out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + protected: + FMT_CONSTEXPR20 void grow(size_t) override { + if (this->size() == buffer_size) flush(); + } + + void flush() { + auto size = this->size(); + this->clear(); + out_ = copy_str(data_, data_ + this->limit(size), out_); + } + + public: + explicit iterator_buffer(OutputIt out, size_t n = buffer_size) + : Traits(n), buffer(data_, 0, buffer_size), out_(out) {} + iterator_buffer(iterator_buffer&& other) + : Traits(other), buffer(data_, 0, buffer_size), out_(other.out_) {} + ~iterator_buffer() { flush(); } + + auto out() -> OutputIt { + flush(); + return out_; + } + auto count() const -> size_t { return Traits::count() + this->size(); } +}; + +template +class iterator_buffer final + : public fixed_buffer_traits, + public buffer { + private: + T* out_; + enum { buffer_size = 256 }; + T data_[buffer_size]; + + protected: + FMT_CONSTEXPR20 void grow(size_t) override { + if (this->size() == this->capacity()) flush(); + } + + void flush() { + size_t n = this->limit(this->size()); + if (this->data() == out_) { + out_ += n; + this->set(data_, buffer_size); + } + this->clear(); + } + + public: + explicit iterator_buffer(T* out, size_t n = buffer_size) + : fixed_buffer_traits(n), buffer(out, 0, n), out_(out) {} + iterator_buffer(iterator_buffer&& other) + : fixed_buffer_traits(other), + buffer(std::move(other)), + out_(other.out_) { + if (this->data() != out_) { + this->set(data_, buffer_size); + this->clear(); + } + } + ~iterator_buffer() { flush(); } + + auto out() -> T* { + flush(); + return out_; + } + auto count() const -> size_t { + return fixed_buffer_traits::count() + this->size(); + } +}; + +template class iterator_buffer final : public buffer { + protected: + FMT_CONSTEXPR20 void grow(size_t) override {} + + public: + explicit iterator_buffer(T* out, size_t = 0) : buffer(out, 0, ~size_t()) {} + + auto out() -> T* { return &*this->end(); } +}; + +// A buffer that writes to a container with the contiguous storage. +template +class iterator_buffer, + enable_if_t::value, + typename Container::value_type>> + final : public buffer { + private: + Container& container_; + + protected: + FMT_CONSTEXPR20 void grow(size_t capacity) override { + container_.resize(capacity); + this->set(&container_[0], capacity); + } + + public: + explicit iterator_buffer(Container& c) + : buffer(c.size()), container_(c) {} + explicit iterator_buffer(std::back_insert_iterator out, size_t = 0) + : iterator_buffer(get_container(out)) {} + + auto out() -> std::back_insert_iterator { + return std::back_inserter(container_); + } +}; + +// A buffer that counts the number of code units written discarding the output. +template class counting_buffer final : public buffer { + private: + enum { buffer_size = 256 }; + T data_[buffer_size]; + size_t count_ = 0; + + protected: + FMT_CONSTEXPR20 void grow(size_t) override { + if (this->size() != buffer_size) return; + count_ += this->size(); + this->clear(); + } + + public: + counting_buffer() : buffer(data_, 0, buffer_size) {} + + auto count() -> size_t { return count_ + this->size(); } +}; +} // namespace detail + +template +FMT_CONSTEXPR void basic_format_parse_context::do_check_arg_id(int id) { + // Argument id is only checked at compile-time during parsing because + // formatting has its own validation. + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context; + if (id >= static_cast(this)->num_args()) + detail::throw_format_error("argument not found"); + } +} + +template +FMT_CONSTEXPR void basic_format_parse_context::check_dynamic_spec( + int arg_id) { + if (detail::is_constant_evaluated() && + (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) { + using context = detail::compile_parse_context; + static_cast(this)->check_dynamic_spec(arg_id); + } +} + +FMT_EXPORT template class basic_format_arg; +FMT_EXPORT template class basic_format_args; +FMT_EXPORT template class dynamic_format_arg_store; + +// A formatter for objects of type T. +FMT_EXPORT +template +struct formatter { + // A deleted default constructor indicates a disabled formatter. + formatter() = delete; +}; + +// Specifies if T has an enabled formatter specialization. A type can be +// formattable even if it doesn't have a formatter e.g. via a conversion. +template +using has_formatter = + std::is_constructible>; + +// An output iterator that appends to a buffer. +// It is used to reduce symbol sizes for the common case. +class appender : public std::back_insert_iterator> { + using base = std::back_insert_iterator>; + + public: + using std::back_insert_iterator>::back_insert_iterator; + appender(base it) noexcept : base(it) {} + FMT_UNCHECKED_ITERATOR(appender); + + auto operator++() noexcept -> appender& { return *this; } + auto operator++(int) noexcept -> appender { return *this; } +}; + +namespace detail { + +template +constexpr auto has_const_formatter_impl(T*) + -> decltype(typename Context::template formatter_type().format( + std::declval(), std::declval()), + true) { + return true; +} +template +constexpr auto has_const_formatter_impl(...) -> bool { + return false; +} +template +constexpr auto has_const_formatter() -> bool { + return has_const_formatter_impl(static_cast(nullptr)); +} + +template +using buffer_appender = conditional_t::value, appender, + std::back_insert_iterator>>; + +// Maps an output iterator to a buffer. +template +auto get_buffer(OutputIt out) -> iterator_buffer { + return iterator_buffer(out); +} +template , Buf>::value)> +auto get_buffer(std::back_insert_iterator out) -> buffer& { + return get_container(out); +} + +template +FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { + return buf.out(); +} +template +auto get_iterator(buffer&, OutputIt out) -> OutputIt { + return out; +} + +struct view {}; + +template struct named_arg : view { + const Char* name; + const T& value; + named_arg(const Char* n, const T& v) : name(n), value(v) {} +}; + +template struct named_arg_info { + const Char* name; + int id; +}; + +template +struct arg_data { + // args_[0].named_args points to named_args_ to avoid bloating format_args. + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)]; + named_arg_info named_args_[NUM_NAMED_ARGS]; + + template + arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {} + arg_data(const arg_data& other) = delete; + auto args() const -> const T* { return args_ + 1; } + auto named_args() -> named_arg_info* { return named_args_; } +}; + +template +struct arg_data { + // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. + T args_[NUM_ARGS != 0 ? NUM_ARGS : +1]; + + template + FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {} + FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; } + FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t { + return nullptr; + } +}; + +template +inline void init_named_args(named_arg_info*, int, int) {} + +template struct is_named_arg : std::false_type {}; +template struct is_statically_named_arg : std::false_type {}; + +template +struct is_named_arg> : std::true_type {}; + +template ::value)> +void init_named_args(named_arg_info* named_args, int arg_count, + int named_arg_count, const T&, const Tail&... args) { + init_named_args(named_args, arg_count + 1, named_arg_count, args...); +} + +template ::value)> +void init_named_args(named_arg_info* named_args, int arg_count, + int named_arg_count, const T& arg, const Tail&... args) { + named_args[named_arg_count++] = {arg.name, arg_count}; + init_named_args(named_args, arg_count + 1, named_arg_count, args...); +} + +template +FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int, + const Args&...) {} + +template constexpr auto count() -> size_t { return B ? 1 : 0; } +template constexpr auto count() -> size_t { + return (B1 ? 1 : 0) + count(); +} + +template constexpr auto count_named_args() -> size_t { + return count::value...>(); +} + +template +constexpr auto count_statically_named_args() -> size_t { + return count::value...>(); +} + +struct unformattable {}; +struct unformattable_char : unformattable {}; +struct unformattable_pointer : unformattable {}; + +template struct string_value { + const Char* data; + size_t size; +}; + +template struct named_arg_value { + const named_arg_info* data; + size_t size; +}; + +template struct custom_value { + using parse_context = typename Context::parse_context_type; + void* value; + void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); +}; + +// A formatting argument value. +template class value { + public: + using char_type = typename Context::char_type; + + union { + monostate no_value; + int int_value; + unsigned uint_value; + long long long_long_value; + unsigned long long ulong_long_value; + int128_opt int128_value; + uint128_opt uint128_value; + bool bool_value; + char_type char_value; + float float_value; + double double_value; + long double long_double_value; + const void* pointer; + string_value string; + custom_value custom; + named_arg_value named_args; + }; + + constexpr FMT_INLINE value() : no_value() {} + constexpr FMT_INLINE value(int val) : int_value(val) {} + constexpr FMT_INLINE value(unsigned val) : uint_value(val) {} + constexpr FMT_INLINE value(long long val) : long_long_value(val) {} + constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {} + FMT_INLINE value(int128_opt val) : int128_value(val) {} + FMT_INLINE value(uint128_opt val) : uint128_value(val) {} + constexpr FMT_INLINE value(float val) : float_value(val) {} + constexpr FMT_INLINE value(double val) : double_value(val) {} + FMT_INLINE value(long double val) : long_double_value(val) {} + constexpr FMT_INLINE value(bool val) : bool_value(val) {} + constexpr FMT_INLINE value(char_type val) : char_value(val) {} + FMT_CONSTEXPR FMT_INLINE value(const char_type* val) { + string.data = val; + if (is_constant_evaluated()) string.size = {}; + } + FMT_CONSTEXPR FMT_INLINE value(basic_string_view val) { + string.data = val.data(); + string.size = val.size(); + } + FMT_INLINE value(const void* val) : pointer(val) {} + FMT_INLINE value(const named_arg_info* args, size_t size) + : named_args{args, size} {} + + template FMT_CONSTEXPR FMT_INLINE value(T& val) { + using value_type = remove_const_t; + custom.value = const_cast(&val); + // Get the formatter type through the context to allow different contexts + // have different extension points, e.g. `formatter` for `format` and + // `printf_formatter` for `printf`. + custom.format = format_custom_arg< + value_type, typename Context::template formatter_type>; + } + value(unformattable); + value(unformattable_char); + value(unformattable_pointer); + + private: + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg(void* arg, + typename Context::parse_context_type& parse_ctx, + Context& ctx) { + auto f = Formatter(); + parse_ctx.advance_to(f.parse(parse_ctx)); + using qualified_type = + conditional_t(), const T, T>; + ctx.advance_to(f.format(*static_cast(arg), ctx)); + } +}; + +// To minimize the number of types we need to deal with, long is translated +// either to int or to long long depending on its size. +enum { long_short = sizeof(long) == sizeof(int) }; +using long_type = conditional_t; +using ulong_type = conditional_t; + +template struct format_as_result { + template ::value || std::is_class::value)> + static auto map(U*) -> decltype(format_as(std::declval())); + static auto map(...) -> void; + + using type = decltype(map(static_cast(nullptr))); +}; +template using format_as_t = typename format_as_result::type; + +template +struct has_format_as + : bool_constant, void>::value> {}; + +// Maps formatting arguments to core types. +// arg_mapper reports errors by returning unformattable instead of using +// static_assert because it's used in the is_formattable trait. +template struct arg_mapper { + using char_type = typename Context::char_type; + + FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val) + -> unsigned long long { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type { + return val; + } + template ::value || +#ifdef __cpp_char8_t + std::is_same::value || +#endif + std::is_same::value || + std::is_same::value) && + !std::is_same::value, + int> = 0> + FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char { + return {}; + } + + FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double { + return val; + } + + FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* { + return val; + } + template ::value && !std::is_pointer::value && + std::is_same>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& val) + -> basic_string_view { + return to_string_view(val); + } + template ::value && !std::is_pointer::value && + !std::is_same>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char { + return {}; + } + + FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; } + FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* { + return val; + } + FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* { + return val; + } + + // Use SFINAE instead of a const T* parameter to avoid a conflict with the + // array overload. + template < + typename T, + FMT_ENABLE_IF( + std::is_pointer::value || std::is_member_pointer::value || + std::is_function::type>::value || + (std::is_convertible::value && + !std::is_convertible::value && + !has_formatter::value))> + FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer { + return {}; + } + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] { + return values; + } + + // Only map owning types because mapping views can be unsafe. + template , + FMT_ENABLE_IF(std::is_arithmetic::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& val) -> decltype(this->map(U())) { + return map(format_as(val)); + } + + template > + struct formattable : bool_constant() || + (has_formatter::value && + !std::is_const::value)> {}; + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& { + return val; + } + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable { + return {}; + } + + template , + FMT_ENABLE_IF((std::is_class::value || std::is_enum::value || + std::is_union::value) && + !is_string::value && !is_char::value && + !is_named_arg::value && + !std::is_arithmetic>::value)> + FMT_CONSTEXPR FMT_INLINE auto map(T& val) -> decltype(this->do_map(val)) { + return do_map(val); + } + + template ::value)> + FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg) + -> decltype(this->map(named_arg.value)) { + return map(named_arg.value); + } + + auto map(...) -> unformattable { return {}; } +}; + +// A type constant after applying arg_mapper. +template +using mapped_type_constant = + type_constant().map(std::declval())), + typename Context::char_type>; + +enum { packed_arg_bits = 4 }; +// Maximum number of arguments with packed types. +enum { max_packed_args = 62 / packed_arg_bits }; +enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; +enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; + +template +auto copy_str(InputIt begin, InputIt end, appender out) -> appender { + get_container(out).append(begin, end); + return out; +} + +template +FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt { + return detail::copy_str(rng.begin(), rng.end(), out); +} + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500 +// A workaround for gcc 4.8 to make void_t work in a SFINAE context. +template struct void_t_impl { using type = void; }; +template using void_t = typename void_t_impl::type; +#else +template using void_t = void; +#endif + +template +struct is_output_iterator : std::false_type {}; + +template +struct is_output_iterator< + It, T, + void_t::iterator_category, + decltype(*std::declval() = std::declval())>> + : std::true_type {}; + +template struct is_back_insert_iterator : std::false_type {}; +template +struct is_back_insert_iterator> + : std::true_type {}; + +// A type-erased reference to an std::locale to avoid a heavy include. +class locale_ref { + private: + const void* locale_; // A type-erased pointer to std::locale. + + public: + constexpr FMT_INLINE locale_ref() : locale_(nullptr) {} + template explicit locale_ref(const Locale& loc); + + explicit operator bool() const noexcept { return locale_ != nullptr; } + + template auto get() const -> Locale; +}; + +template constexpr auto encode_types() -> unsigned long long { + return 0; +} + +template +constexpr auto encode_types() -> unsigned long long { + return static_cast(mapped_type_constant::value) | + (encode_types() << packed_arg_bits); +} + +template +FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value { + auto&& arg = arg_mapper().map(val); + using arg_type = remove_cvref_t; + + constexpr bool formattable_char = + !std::is_same::value; + static_assert(formattable_char, "Mixing character types is disallowed."); + + // Formatting of arbitrary pointers is disallowed. If you want to format a + // pointer cast it to `void*` or `const void*`. In particular, this forbids + // formatting of `[const] volatile char*` printed as bool by iostreams. + constexpr bool formattable_pointer = + !std::is_same::value; + static_assert(formattable_pointer, + "Formatting of non-void pointers is disallowed."); + + constexpr bool formattable = !std::is_same::value; + static_assert( + formattable, + "Cannot format an argument. To make type T formattable provide a " + "formatter specialization: https://fmt.dev/latest/api.html#udt"); + return {arg}; +} + +template +FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg { + auto arg = basic_format_arg(); + arg.type_ = mapped_type_constant::value; + arg.value_ = make_arg(val); + return arg; +} + +template +FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg { + return make_arg(val); +} +} // namespace detail +FMT_BEGIN_EXPORT + +// A formatting argument. It is a trivially copyable/constructible type to +// allow storage in basic_memory_buffer. +template class basic_format_arg { + private: + detail::value value_; + detail::type type_; + + template + friend FMT_CONSTEXPR auto detail::make_arg(T& value) + -> basic_format_arg; + + template + friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis, + const basic_format_arg& arg) + -> decltype(vis(0)); + + friend class basic_format_args; + friend class dynamic_format_arg_store; + + using char_type = typename Context::char_type; + + template + friend struct detail::arg_data; + + basic_format_arg(const detail::named_arg_info* args, size_t size) + : value_(args, size) {} + + public: + class handle { + public: + explicit handle(detail::custom_value custom) : custom_(custom) {} + + void format(typename Context::parse_context_type& parse_ctx, + Context& ctx) const { + custom_.format(custom_.value, parse_ctx, ctx); + } + + private: + detail::custom_value custom_; + }; + + constexpr basic_format_arg() : type_(detail::type::none_type) {} + + constexpr explicit operator bool() const noexcept { + return type_ != detail::type::none_type; + } + + auto type() const -> detail::type { return type_; } + + auto is_integral() const -> bool { return detail::is_integral_type(type_); } + auto is_arithmetic() const -> bool { + return detail::is_arithmetic_type(type_); + } +}; + +/** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + ``vis(value)`` will be called with the value of type ``double``. + \endrst + */ +FMT_EXPORT +template +FMT_CONSTEXPR FMT_INLINE auto visit_format_arg( + Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) { + switch (arg.type_) { + case detail::type::none_type: + break; + case detail::type::int_type: + return vis(arg.value_.int_value); + case detail::type::uint_type: + return vis(arg.value_.uint_value); + case detail::type::long_long_type: + return vis(arg.value_.long_long_value); + case detail::type::ulong_long_type: + return vis(arg.value_.ulong_long_value); + case detail::type::int128_type: + return vis(detail::convert_for_visit(arg.value_.int128_value)); + case detail::type::uint128_type: + return vis(detail::convert_for_visit(arg.value_.uint128_value)); + case detail::type::bool_type: + return vis(arg.value_.bool_value); + case detail::type::char_type: + return vis(arg.value_.char_value); + case detail::type::float_type: + return vis(arg.value_.float_value); + case detail::type::double_type: + return vis(arg.value_.double_value); + case detail::type::long_double_type: + return vis(arg.value_.long_double_value); + case detail::type::cstring_type: + return vis(arg.value_.string.data); + case detail::type::string_type: + using sv = basic_string_view; + return vis(sv(arg.value_.string.data, arg.value_.string.size)); + case detail::type::pointer_type: + return vis(arg.value_.pointer); + case detail::type::custom_type: + return vis(typename basic_format_arg::handle(arg.value_.custom)); + } + return vis(monostate()); +} + +// Formatting context. +template class basic_format_context { + private: + OutputIt out_; + basic_format_args args_; + detail::locale_ref loc_; + + public: + using iterator = OutputIt; + using format_arg = basic_format_arg; + using format_args = basic_format_args; + using parse_context_type = basic_format_parse_context; + template using formatter_type = formatter; + + /** The character type for the output. */ + using char_type = Char; + + basic_format_context(basic_format_context&&) = default; + basic_format_context(const basic_format_context&) = delete; + void operator=(const basic_format_context&) = delete; + /** + Constructs a ``basic_format_context`` object. References to the arguments + are stored in the object so make sure they have appropriate lifetimes. + */ + constexpr basic_format_context(OutputIt out, format_args ctx_args, + detail::locale_ref loc = {}) + : out_(out), args_(ctx_args), loc_(loc) {} + + constexpr auto arg(int id) const -> format_arg { return args_.get(id); } + FMT_CONSTEXPR auto arg(basic_string_view name) -> format_arg { + return args_.get(name); + } + FMT_CONSTEXPR auto arg_id(basic_string_view name) -> int { + return args_.get_id(name); + } + auto args() const -> const format_args& { return args_; } + + FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; } + void on_error(const char* message) { error_handler().on_error(message); } + + // Returns an iterator to the beginning of the output range. + FMT_CONSTEXPR auto out() -> iterator { return out_; } + + // Advances the begin iterator to ``it``. + void advance_to(iterator it) { + if (!detail::is_back_insert_iterator()) out_ = it; + } + + FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; } +}; + +template +using buffer_context = + basic_format_context, Char>; +using format_context = buffer_context; + +template +using is_formattable = bool_constant>() + .map(std::declval()))>::value>; + +/** + \rst + An array of references to arguments. It can be implicitly converted into + `~fmt::basic_format_args` for passing into type-erased formatting functions + such as `~fmt::vformat`. + \endrst + */ +template +class format_arg_store +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 + // Workaround a GCC template argument substitution bug. + : public basic_format_args +#endif +{ + private: + static const size_t num_args = sizeof...(Args); + static constexpr size_t num_named_args = detail::count_named_args(); + static const bool is_packed = num_args <= detail::max_packed_args; + + using value_type = conditional_t, + basic_format_arg>; + + detail::arg_data + data_; + + friend class basic_format_args; + + static constexpr unsigned long long desc = + (is_packed ? detail::encode_types() + : detail::is_unpacked_bit | num_args) | + (num_named_args != 0 + ? static_cast(detail::has_named_args_bit) + : 0); + + public: + template + FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args) + : +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 + basic_format_args(*this), +#endif + data_{detail::make_arg(args)...} { + if (num_named_args != 0) + detail::init_named_args(data_.named_args(), 0, 0, args...); + } +}; + +/** + \rst + Constructs a `~fmt::format_arg_store` object that contains references to + arguments and can be implicitly converted to `~fmt::format_args`. `Context` + can be omitted in which case it defaults to `~fmt::format_context`. + See `~fmt::arg` for lifetime considerations. + \endrst + */ +// Arguments are taken by lvalue references to avoid some lifetime issues. +template +constexpr auto make_format_args(T&... args) + -> format_arg_store...> { + return {args...}; +} + +/** + \rst + Returns a named argument to be used in a formatting function. + It should only be used in a call to a formatting function or + `dynamic_format_arg_store::push_back`. + + **Example**:: + + fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); + \endrst + */ +template +inline auto arg(const Char* name, const T& arg) -> detail::named_arg { + static_assert(!detail::is_named_arg(), "nested named arguments"); + return {name, arg}; +} +FMT_END_EXPORT + +/** + \rst + A view of a collection of formatting arguments. To avoid lifetime issues it + should only be used as a parameter type in type-erased functions such as + ``vformat``:: + + void vlog(string_view format_str, format_args args); // OK + format_args args = make_format_args(); // Error: dangling reference + \endrst + */ +template class basic_format_args { + public: + using size_type = int; + using format_arg = basic_format_arg; + + private: + // A descriptor that contains information about formatting arguments. + // If the number of arguments is less or equal to max_packed_args then + // argument types are passed in the descriptor. This reduces binary code size + // per formatting function call. + unsigned long long desc_; + union { + // If is_packed() returns true then argument values are stored in values_; + // otherwise they are stored in args_. This is done to improve cache + // locality and reduce compiled code size since storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. + const detail::value* values_; + const format_arg* args_; + }; + + constexpr auto is_packed() const -> bool { + return (desc_ & detail::is_unpacked_bit) == 0; + } + auto has_named_args() const -> bool { + return (desc_ & detail::has_named_args_bit) != 0; + } + + FMT_CONSTEXPR auto type(int index) const -> detail::type { + int shift = index * detail::packed_arg_bits; + unsigned int mask = (1 << detail::packed_arg_bits) - 1; + return static_cast((desc_ >> shift) & mask); + } + + constexpr FMT_INLINE basic_format_args(unsigned long long desc, + const detail::value* values) + : desc_(desc), values_(values) {} + constexpr basic_format_args(unsigned long long desc, const format_arg* args) + : desc_(desc), args_(args) {} + + public: + constexpr basic_format_args() : desc_(0), args_(nullptr) {} + + /** + \rst + Constructs a `basic_format_args` object from `~fmt::format_arg_store`. + \endrst + */ + template + constexpr FMT_INLINE basic_format_args( + const format_arg_store& store) + : basic_format_args(format_arg_store::desc, + store.data_.args()) {} + + /** + \rst + Constructs a `basic_format_args` object from + `~fmt::dynamic_format_arg_store`. + \endrst + */ + constexpr FMT_INLINE basic_format_args( + const dynamic_format_arg_store& store) + : basic_format_args(store.get_types(), store.data()) {} + + /** + \rst + Constructs a `basic_format_args` object from a dynamic set of arguments. + \endrst + */ + constexpr basic_format_args(const format_arg* args, int count) + : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count), + args) {} + + /** Returns the argument with the specified id. */ + FMT_CONSTEXPR auto get(int id) const -> format_arg { + format_arg arg; + if (!is_packed()) { + if (id < max_size()) arg = args_[id]; + return arg; + } + if (id >= detail::max_packed_args) return arg; + arg.type_ = type(id); + if (arg.type_ == detail::type::none_type) return arg; + arg.value_ = values_[id]; + return arg; + } + + template + auto get(basic_string_view name) const -> format_arg { + int id = get_id(name); + return id >= 0 ? get(id) : format_arg(); + } + + template + auto get_id(basic_string_view name) const -> int { + if (!has_named_args()) return -1; + const auto& named_args = + (is_packed() ? values_[-1] : args_[-1].value_).named_args; + for (size_t i = 0; i < named_args.size; ++i) { + if (named_args.data[i].name == name) return named_args.data[i].id; + } + return -1; + } + + auto max_size() const -> int { + unsigned long long max_packed = detail::max_packed_args; + return static_cast(is_packed() ? max_packed + : desc_ & ~detail::is_unpacked_bit); + } +}; + +/** An alias to ``basic_format_args``. */ +// A separate type would result in shorter symbols but break ABI compatibility +// between clang and gcc on ARM (#1919). +FMT_EXPORT using format_args = basic_format_args; + +// We cannot use enum classes as bit fields because of a gcc bug, so we put them +// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414). +// Additionally, if an underlying type is specified, older gcc incorrectly warns +// that the type is too small. Both bugs are fixed in gcc 9.3. +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903 +# define FMT_ENUM_UNDERLYING_TYPE(type) +#else +# define FMT_ENUM_UNDERLYING_TYPE(type) : type +#endif +namespace align { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center, + numeric}; +} +using align_t = align::type; +namespace sign { +enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space}; +} +using sign_t = sign::type; + +namespace detail { + +// Workaround an array initialization issue in gcc 4.8. +template struct fill_t { + private: + enum { max_size = 4 }; + Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)}; + unsigned char size_ = 1; + + public: + FMT_CONSTEXPR void operator=(basic_string_view s) { + auto size = s.size(); + FMT_ASSERT(size <= max_size, "invalid fill"); + for (size_t i = 0; i < size; ++i) data_[i] = s[i]; + size_ = static_cast(size); + } + + constexpr auto size() const -> size_t { return size_; } + constexpr auto data() const -> const Char* { return data_; } + + FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; } + FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& { + return data_[index]; + } +}; +} // namespace detail + +enum class presentation_type : unsigned char { + none, + dec, // 'd' + oct, // 'o' + hex_lower, // 'x' + hex_upper, // 'X' + bin_lower, // 'b' + bin_upper, // 'B' + hexfloat_lower, // 'a' + hexfloat_upper, // 'A' + exp_lower, // 'e' + exp_upper, // 'E' + fixed_lower, // 'f' + fixed_upper, // 'F' + general_lower, // 'g' + general_upper, // 'G' + chr, // 'c' + string, // 's' + pointer, // 'p' + debug // '?' +}; + +// Format specifiers for built-in and string types. +template struct format_specs { + int width; + int precision; + presentation_type type; + align_t align : 4; + sign_t sign : 3; + bool alt : 1; // Alternate form ('#'). + bool localized : 1; + detail::fill_t fill; + + constexpr format_specs() + : width(0), + precision(-1), + type(presentation_type::none), + align(align::none), + sign(sign::none), + alt(false), + localized(false) {} +}; + +namespace detail { + +enum class arg_id_kind { none, index, name }; + +// An argument reference. +template struct arg_ref { + FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {} + + FMT_CONSTEXPR explicit arg_ref(int index) + : kind(arg_id_kind::index), val(index) {} + FMT_CONSTEXPR explicit arg_ref(basic_string_view name) + : kind(arg_id_kind::name), val(name) {} + + FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& { + kind = arg_id_kind::index; + val.index = idx; + return *this; + } + + arg_id_kind kind; + union value { + FMT_CONSTEXPR value(int idx = 0) : index(idx) {} + FMT_CONSTEXPR value(basic_string_view n) : name(n) {} + + int index; + basic_string_view name; + } val; +}; + +// Format specifiers with width and precision resolved at formatting rather +// than parsing time to allow reusing the same parsed specifiers with +// different sets of arguments (precompilation of format strings). +template +struct dynamic_format_specs : format_specs { + arg_ref width_ref; + arg_ref precision_ref; +}; + +// Converts a character to ASCII. Returns '\0' on conversion failure. +template ::value)> +constexpr auto to_ascii(Char c) -> char { + return c <= 0xff ? static_cast(c) : '\0'; +} +template ::value)> +constexpr auto to_ascii(Char c) -> char { + return c <= 0xff ? static_cast(c) : '\0'; +} + +// Returns the number of code units in a code point or 1 on error. +template +FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { + if (const_check(sizeof(Char) != 1)) return 1; + auto c = static_cast(*begin); + return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1; +} + +// Return the result via the out param to workaround gcc bug 77539. +template +FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { + for (out = first; out != last; ++out) { + if (*out == value) return true; + } + return false; +} + +template <> +inline auto find(const char* first, const char* last, char value, + const char*& out) -> bool { + out = static_cast( + std::memchr(first, value, to_unsigned(last - first))); + return out != nullptr; +} + +// Parses the range [begin, end) as an unsigned integer. This function assumes +// that the range is non-empty and the first character is a digit. +template +FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, + int error_value) noexcept -> int { + FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); + unsigned value = 0, prev = 0; + auto p = begin; + do { + prev = value; + value = value * 10 + unsigned(*p - '0'); + ++p; + } while (p != end && '0' <= *p && *p <= '9'); + auto num_digits = p - begin; + begin = p; + if (num_digits <= std::numeric_limits::digits10) + return static_cast(value); + // Check for overflow. + const unsigned max = to_unsigned((std::numeric_limits::max)()); + return num_digits == std::numeric_limits::digits10 + 1 && + prev * 10ull + unsigned(p[-1] - '0') <= max + ? static_cast(value) + : error_value; +} + +FMT_CONSTEXPR inline auto parse_align(char c) -> align_t { + switch (c) { + case '<': + return align::left; + case '>': + return align::right; + case '^': + return align::center; + } + return align::none; +} + +template constexpr auto is_name_start(Char c) -> bool { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; +} + +template +FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + Char c = *begin; + if (c >= '0' && c <= '9') { + int index = 0; + constexpr int max = (std::numeric_limits::max)(); + if (c != '0') + index = parse_nonnegative_int(begin, end, max); + else + ++begin; + if (begin == end || (*begin != '}' && *begin != ':')) + throw_format_error("invalid format string"); + else + handler.on_index(index); + return begin; + } + if (!is_name_start(c)) { + throw_format_error("invalid format string"); + return begin; + } + auto it = begin; + do { + ++it; + } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); + handler.on_name({begin, to_unsigned(it - begin)}); + return it; +} + +template +FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + FMT_ASSERT(begin != end, ""); + Char c = *begin; + if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler); + handler.on_auto(); + return begin; +} + +template struct dynamic_spec_id_handler { + basic_format_parse_context& ctx; + arg_ref& ref; + + FMT_CONSTEXPR void on_auto() { + int id = ctx.next_arg_id(); + ref = arg_ref(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_index(int id) { + ref = arg_ref(id); + ctx.check_arg_id(id); + ctx.check_dynamic_spec(id); + } + FMT_CONSTEXPR void on_name(basic_string_view id) { + ref = arg_ref(id); + ctx.check_arg_id(id); + } +}; + +// Parses [integer | "{" [arg_id] "}"]. +template +FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, + int& value, arg_ref& ref, + basic_format_parse_context& ctx) + -> const Char* { + FMT_ASSERT(begin != end, ""); + if ('0' <= *begin && *begin <= '9') { + int val = parse_nonnegative_int(begin, end, -1); + if (val != -1) + value = val; + else + throw_format_error("number is too big"); + } else if (*begin == '{') { + ++begin; + auto handler = dynamic_spec_id_handler{ctx, ref}; + if (begin != end) begin = parse_arg_id(begin, end, handler); + if (begin != end && *begin == '}') return ++begin; + throw_format_error("invalid format string"); + } + return begin; +} + +template +FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, + int& value, arg_ref& ref, + basic_format_parse_context& ctx) + -> const Char* { + ++begin; + if (begin == end || *begin == '}') { + throw_format_error("invalid precision"); + return begin; + } + return parse_dynamic_spec(begin, end, value, ref, ctx); +} + +enum class state { start, align, sign, hash, zero, width, precision, locale }; + +// Parses standard format specifiers. +template +FMT_CONSTEXPR FMT_INLINE auto parse_format_specs( + const Char* begin, const Char* end, dynamic_format_specs& specs, + basic_format_parse_context& ctx, type arg_type) -> const Char* { + auto c = '\0'; + if (end - begin > 1) { + auto next = to_ascii(begin[1]); + c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; + } else { + if (begin == end) return begin; + c = to_ascii(*begin); + } + + struct { + state current_state = state::start; + FMT_CONSTEXPR void operator()(state s, bool valid = true) { + if (current_state >= s || !valid) + throw_format_error("invalid format specifier"); + current_state = s; + } + } enter_state; + + using pres = presentation_type; + constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; + struct { + const Char*& begin; + dynamic_format_specs& specs; + type arg_type; + + FMT_CONSTEXPR auto operator()(pres type, int set) -> const Char* { + if (!in(arg_type, set)) throw_format_error("invalid format specifier"); + specs.type = type; + return begin + 1; + } + } parse_presentation_type{begin, specs, arg_type}; + + for (;;) { + switch (c) { + case '<': + case '>': + case '^': + enter_state(state::align); + specs.align = parse_align(c); + ++begin; + break; + case '+': + case '-': + case ' ': + enter_state(state::sign, in(arg_type, sint_set | float_set)); + switch (c) { + case '+': + specs.sign = sign::plus; + break; + case '-': + specs.sign = sign::minus; + break; + case ' ': + specs.sign = sign::space; + break; + } + ++begin; + break; + case '#': + enter_state(state::hash, is_arithmetic_type(arg_type)); + specs.alt = true; + ++begin; + break; + case '0': + enter_state(state::zero); + if (!is_arithmetic_type(arg_type)) + throw_format_error("format specifier requires numeric argument"); + if (specs.align == align::none) { + // Ignore 0 if align is specified for compatibility with std::format. + specs.align = align::numeric; + specs.fill[0] = Char('0'); + } + ++begin; + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '{': + enter_state(state::width); + begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx); + break; + case '.': + enter_state(state::precision, + in(arg_type, float_set | string_set | cstring_set)); + begin = parse_precision(begin, end, specs.precision, specs.precision_ref, + ctx); + break; + case 'L': + enter_state(state::locale, is_arithmetic_type(arg_type)); + specs.localized = true; + ++begin; + break; + case 'd': + return parse_presentation_type(pres::dec, integral_set); + case 'o': + return parse_presentation_type(pres::oct, integral_set); + case 'x': + return parse_presentation_type(pres::hex_lower, integral_set); + case 'X': + return parse_presentation_type(pres::hex_upper, integral_set); + case 'b': + return parse_presentation_type(pres::bin_lower, integral_set); + case 'B': + return parse_presentation_type(pres::bin_upper, integral_set); + case 'a': + return parse_presentation_type(pres::hexfloat_lower, float_set); + case 'A': + return parse_presentation_type(pres::hexfloat_upper, float_set); + case 'e': + return parse_presentation_type(pres::exp_lower, float_set); + case 'E': + return parse_presentation_type(pres::exp_upper, float_set); + case 'f': + return parse_presentation_type(pres::fixed_lower, float_set); + case 'F': + return parse_presentation_type(pres::fixed_upper, float_set); + case 'g': + return parse_presentation_type(pres::general_lower, float_set); + case 'G': + return parse_presentation_type(pres::general_upper, float_set); + case 'c': + return parse_presentation_type(pres::chr, integral_set); + case 's': + return parse_presentation_type(pres::string, + bool_set | string_set | cstring_set); + case 'p': + return parse_presentation_type(pres::pointer, pointer_set | cstring_set); + case '?': + return parse_presentation_type(pres::debug, + char_set | string_set | cstring_set); + case '}': + return begin; + default: { + if (*begin == '}') return begin; + // Parse fill and alignment. + auto fill_end = begin + code_point_length(begin); + if (end - fill_end <= 0) { + throw_format_error("invalid format specifier"); + return begin; + } + if (*begin == '{') { + throw_format_error("invalid fill character '{'"); + return begin; + } + auto align = parse_align(to_ascii(*fill_end)); + enter_state(state::align, align != align::none); + specs.fill = {begin, to_unsigned(fill_end - begin)}; + specs.align = align; + begin = fill_end + 1; + } + } + if (begin == end) return begin; + c = to_ascii(*begin); + } +} + +template +FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end, + Handler&& handler) -> const Char* { + struct id_adapter { + Handler& handler; + int arg_id; + + FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); } + FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } + FMT_CONSTEXPR void on_name(basic_string_view id) { + arg_id = handler.on_arg_id(id); + } + }; + + ++begin; + if (begin == end) return handler.on_error("invalid format string"), end; + if (*begin == '}') { + handler.on_replacement_field(handler.on_arg_id(), begin); + } else if (*begin == '{') { + handler.on_text(begin, begin + 1); + } else { + auto adapter = id_adapter{handler, 0}; + begin = parse_arg_id(begin, end, adapter); + Char c = begin != end ? *begin : Char(); + if (c == '}') { + handler.on_replacement_field(adapter.arg_id, begin); + } else if (c == ':') { + begin = handler.on_format_specs(adapter.arg_id, begin + 1, end); + if (begin == end || *begin != '}') + return handler.on_error("unknown format specifier"), end; + } else { + return handler.on_error("missing '}' in format string"), end; + } + } + return begin + 1; +} + +template +FMT_CONSTEXPR FMT_INLINE void parse_format_string( + basic_string_view format_str, Handler&& handler) { + auto begin = format_str.data(); + auto end = begin + format_str.size(); + if (end - begin < 32) { + // Use a simple loop instead of memchr for small strings. + const Char* p = begin; + while (p != end) { + auto c = *p++; + if (c == '{') { + handler.on_text(begin, p - 1); + begin = p = parse_replacement_field(p - 1, end, handler); + } else if (c == '}') { + if (p == end || *p != '}') + return handler.on_error("unmatched '}' in format string"); + handler.on_text(begin, p); + begin = ++p; + } + } + handler.on_text(begin, end); + return; + } + struct writer { + FMT_CONSTEXPR void operator()(const Char* from, const Char* to) { + if (from == to) return; + for (;;) { + const Char* p = nullptr; + if (!find(from, to, Char('}'), p)) + return handler_.on_text(from, to); + ++p; + if (p == to || *p != '}') + return handler_.on_error("unmatched '}' in format string"); + handler_.on_text(from, p); + from = p + 1; + } + } + Handler& handler_; + } write = {handler}; + while (begin != end) { + // Doing two passes with memchr (one for '{' and another for '}') is up to + // 2.5x faster than the naive one-pass implementation on big format strings. + const Char* p = begin; + if (*begin != '{' && !find(begin + 1, end, Char('{'), p)) + return write(begin, end); + write(begin, p); + begin = parse_replacement_field(p, end, handler); + } +} + +template ::value> struct strip_named_arg { + using type = T; +}; +template struct strip_named_arg { + using type = remove_cvref_t; +}; + +template +FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx) + -> decltype(ctx.begin()) { + using char_type = typename ParseContext::char_type; + using context = buffer_context; + using mapped_type = conditional_t< + mapped_type_constant::value != type::custom_type, + decltype(arg_mapper().map(std::declval())), + typename strip_named_arg::type>; + return formatter().parse(ctx); +} + +// Checks char specs and returns true iff the presentation type is char-like. +template +FMT_CONSTEXPR auto check_char_specs(const format_specs& specs) -> bool { + if (specs.type != presentation_type::none && + specs.type != presentation_type::chr && + specs.type != presentation_type::debug) { + return false; + } + if (specs.align == align::numeric || specs.sign != sign::none || specs.alt) + throw_format_error("invalid format specifier for char"); + return true; +} + +constexpr FMT_INLINE_VARIABLE int invalid_arg_index = -1; + +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +template +constexpr auto get_arg_index_by_name(basic_string_view name) -> int { + if constexpr (is_statically_named_arg()) { + if (name == T::name) return N; + } + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name(name); + (void)name; // Workaround an MSVC bug about "unused" parameter. + return invalid_arg_index; +} +#endif + +template +FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS + if constexpr (sizeof...(Args) > 0) + return get_arg_index_by_name<0, Args...>(name); +#endif + (void)name; + return invalid_arg_index; +} + +template class format_string_checker { + private: + using parse_context_type = compile_parse_context; + static constexpr int num_args = sizeof...(Args); + + // Format specifier parsing function. + // In the future basic_format_parse_context will replace compile_parse_context + // here and will use is_constant_evaluated and downcasting to access the data + // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1. + using parse_func = const Char* (*)(parse_context_type&); + + parse_context_type context_; + parse_func parse_funcs_[num_args > 0 ? static_cast(num_args) : 1]; + type types_[num_args > 0 ? static_cast(num_args) : 1]; + + public: + explicit FMT_CONSTEXPR format_string_checker(basic_string_view fmt) + : context_(fmt, num_args, types_), + parse_funcs_{&parse_format_specs...}, + types_{mapped_type_constant>::value...} {} + + FMT_CONSTEXPR void on_text(const Char*, const Char*) {} + + FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } + FMT_CONSTEXPR auto on_arg_id(int id) -> int { + return context_.check_arg_id(id), id; + } + FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS + auto index = get_arg_index_by_name(id); + if (index == invalid_arg_index) on_error("named argument is not found"); + return index; +#else + (void)id; + on_error("compile-time checks for named arguments require C++20 support"); + return 0; +#endif + } + + FMT_CONSTEXPR void on_replacement_field(int, const Char*) {} + + FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*) + -> const Char* { + context_.advance_to(begin); + // id >= 0 check is a workaround for gcc 10 bug (#2065). + return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin; + } + + FMT_CONSTEXPR void on_error(const char* message) { + throw_format_error(message); + } +}; + +// Reports a compile-time error if S is not a valid format string. +template ::value)> +FMT_INLINE void check_format_string(const S&) { +#ifdef FMT_ENFORCE_COMPILE_STRING + static_assert(is_compile_string::value, + "FMT_ENFORCE_COMPILE_STRING requires all format strings to use " + "FMT_STRING."); +#endif +} +template ::value)> +void check_format_string(S format_str) { + using char_t = typename S::char_type; + FMT_CONSTEXPR auto s = basic_string_view(format_str); + using checker = format_string_checker...>; + FMT_CONSTEXPR bool error = (parse_format_string(s, checker(s)), true); + ignore_unused(error); +} + +template struct vformat_args { + using type = basic_format_args< + basic_format_context>, Char>>; +}; +template <> struct vformat_args { using type = format_args; }; + +// Use vformat_args and avoid type_identity to keep symbols short. +template +void vformat_to(buffer& buf, basic_string_view fmt, + typename vformat_args::type args, locale_ref loc = {}); + +FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); +#ifndef _WIN32 +inline void vprint_mojibake(std::FILE*, string_view, format_args) {} +#endif +} // namespace detail + +FMT_BEGIN_EXPORT + +// A formatter specialization for natively supported types. +template +struct formatter::value != + detail::type::custom_type>> { + private: + detail::dynamic_format_specs specs_; + + public: + template + FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* { + auto type = detail::type_constant::value; + auto end = + detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type); + if (type == detail::type::char_type) detail::check_char_specs(specs_); + return end; + } + + template ::value, + FMT_ENABLE_IF(U == detail::type::string_type || + U == detail::type::cstring_type || + U == detail::type::char_type)> + FMT_CONSTEXPR void set_debug_format(bool set = true) { + specs_.type = set ? presentation_type::debug : presentation_type::none; + } + + template + FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const + -> decltype(ctx.out()); +}; + +#define FMT_FORMAT_AS(Type, Base) \ + template \ + struct formatter : formatter { \ + template \ + auto format(const Type& val, FormatContext& ctx) const \ + -> decltype(ctx.out()) { \ + return formatter::format(static_cast(val), ctx); \ + } \ + } + +FMT_FORMAT_AS(signed char, int); +FMT_FORMAT_AS(unsigned char, unsigned); +FMT_FORMAT_AS(short, int); +FMT_FORMAT_AS(unsigned short, unsigned); +FMT_FORMAT_AS(long, detail::long_type); +FMT_FORMAT_AS(unsigned long, detail::ulong_type); +FMT_FORMAT_AS(Char*, const Char*); +FMT_FORMAT_AS(std::basic_string, basic_string_view); +FMT_FORMAT_AS(std::nullptr_t, const void*); +FMT_FORMAT_AS(detail::std_string_view, basic_string_view); + +template struct runtime_format_string { + basic_string_view str; +}; + +/** A compile-time format string. */ +template class basic_format_string { + private: + basic_string_view str_; + + public: + template >::value)> + FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) { + static_assert( + detail::count< + (std::is_base_of>::value && + std::is_reference::value)...>() == 0, + "passing views as lvalues is disallowed"); +#ifdef FMT_HAS_CONSTEVAL + if constexpr (detail::count_named_args() == + detail::count_statically_named_args()) { + using checker = + detail::format_string_checker...>; + detail::parse_format_string(str_, checker(s)); + } +#else + detail::check_format_string(s); +#endif + } + basic_format_string(runtime_format_string fmt) : str_(fmt.str) {} + + FMT_INLINE operator basic_string_view() const { return str_; } + FMT_INLINE auto get() const -> basic_string_view { return str_; } +}; + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 +// Workaround broken conversion on older gcc. +template using format_string = string_view; +inline auto runtime(string_view s) -> string_view { return s; } +#else +template +using format_string = basic_format_string...>; +/** + \rst + Creates a runtime format string. + + **Example**:: + + // Check format string at runtime instead of compile-time. + fmt::print(fmt::runtime("{:d}"), "I am not a number"); + \endrst + */ +inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } +#endif + +FMT_API auto vformat(string_view fmt, format_args args) -> std::string; + +/** + \rst + Formats ``args`` according to specifications in ``fmt`` and returns the result + as a string. + + **Example**:: + + #include + std::string message = fmt::format("The answer is {}.", 42); + \endrst +*/ +template +FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) + -> std::string { + return vformat(fmt, fmt::make_format_args(args...)); +} + +/** Formats a string and writes the output to ``out``. */ +template ::value)> +auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt { + auto&& buf = detail::get_buffer(out); + detail::vformat_to(buf, fmt, args, {}); + return detail::get_iterator(buf, out); +} + +/** + \rst + Formats ``args`` according to specifications in ``fmt``, writes the result to + the output iterator ``out`` and returns the iterator past the end of the output + range. `format_to` does not append a terminating null character. + + **Example**:: + + auto out = std::vector(); + fmt::format_to(std::back_inserter(out), "{}", 42); + \endrst + */ +template ::value)> +FMT_INLINE auto format_to(OutputIt out, format_string fmt, T&&... args) + -> OutputIt { + return vformat_to(out, fmt, fmt::make_format_args(args...)); +} + +template struct format_to_n_result { + /** Iterator past the end of the output range. */ + OutputIt out; + /** Total (not truncated) output size. */ + size_t size; +}; + +template ::value)> +auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) + -> format_to_n_result { + using traits = detail::fixed_buffer_traits; + auto buf = detail::iterator_buffer(out, n); + detail::vformat_to(buf, fmt, args, {}); + return {buf.out(), buf.count()}; +} + +/** + \rst + Formats ``args`` according to specifications in ``fmt``, writes up to ``n`` + characters of the result to the output iterator ``out`` and returns the total + (not truncated) output size and the iterator past the end of the output range. + `format_to_n` does not append a terminating null character. + \endrst + */ +template ::value)> +FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, + T&&... args) -> format_to_n_result { + return vformat_to_n(out, n, fmt, fmt::make_format_args(args...)); +} + +/** Returns the number of chars in the output of ``format(fmt, args...)``. */ +template +FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, + T&&... args) -> size_t { + auto buf = detail::counting_buffer<>(); + detail::vformat_to(buf, fmt, fmt::make_format_args(args...), {}); + return buf.count(); +} + +FMT_API void vprint(string_view fmt, format_args args); +FMT_API void vprint(std::FILE* f, string_view fmt, format_args args); + +/** + \rst + Formats ``args`` according to specifications in ``fmt`` and writes the output + to ``stdout``. + + **Example**:: + + fmt::print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +template +FMT_INLINE void print(format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::is_utf8() ? vprint(fmt, vargs) + : detail::vprint_mojibake(stdout, fmt, vargs); +} + +/** + \rst + Formats ``args`` according to specifications in ``fmt`` and writes the + output to the file ``f``. + + **Example**:: + + fmt::print(stderr, "Don't {}!", "panic"); + \endrst + */ +template +FMT_INLINE void print(std::FILE* f, format_string fmt, T&&... args) { + const auto& vargs = fmt::make_format_args(args...); + return detail::is_utf8() ? vprint(f, fmt, vargs) + : detail::vprint_mojibake(f, fmt, vargs); +} + +/** + Formats ``args`` according to specifications in ``fmt`` and writes the + output to the file ``f`` followed by a newline. + */ +template +FMT_INLINE void println(std::FILE* f, format_string fmt, T&&... args) { + return fmt::print(f, "{}\n", fmt::format(fmt, std::forward(args)...)); +} + +/** + Formats ``args`` according to specifications in ``fmt`` and writes the output + to ``stdout`` followed by a newline. + */ +template +FMT_INLINE void println(format_string fmt, T&&... args) { + return fmt::println(stdout, fmt, std::forward(args)...); +} + +FMT_END_EXPORT +FMT_GCC_PRAGMA("GCC pop_options") +FMT_END_NAMESPACE + +#ifdef FMT_HEADER_ONLY +# include "format.h" +#endif +#endif // FMT_CORE_H_ diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h new file mode 100644 index 0000000..dac2d43 --- /dev/null +++ b/include/fmt/format-inl.h @@ -0,0 +1,1662 @@ +// Formatting library for C++ - implementation +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_FORMAT_INL_H_ +#define FMT_FORMAT_INL_H_ + +#include +#include // errno +#include +#include +#include + +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR +# include +#endif + +#ifdef _WIN32 +# include // _isatty +#endif + +#include "format.h" + +FMT_BEGIN_NAMESPACE +namespace detail { + +FMT_FUNC void assert_fail(const char* file, int line, const char* message) { + // Use unchecked std::fprintf to avoid triggering another assertion when + // writing to stderr fails + std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); + // Chosen instead of std::abort to satisfy Clang in CUDA mode during device + // code pass. + std::terminate(); +} + +FMT_FUNC void throw_format_error(const char* message) { + FMT_THROW(format_error(message)); +} + +FMT_FUNC void format_error_code(detail::buffer& out, int error_code, + string_view message) noexcept { + // Report error code making sure that the output fits into + // inline_buffer_size to avoid dynamic memory allocation and potential + // bad_alloc. + out.try_resize(0); + static const char SEP[] = ": "; + static const char ERROR_STR[] = "error "; + // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. + size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; + auto abs_value = static_cast>(error_code); + if (detail::is_negative(error_code)) { + abs_value = 0 - abs_value; + ++error_code_size; + } + error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); + auto it = buffer_appender(out); + if (message.size() <= inline_buffer_size - error_code_size) + format_to(it, FMT_STRING("{}{}"), message, SEP); + format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); + FMT_ASSERT(out.size() <= inline_buffer_size, ""); +} + +FMT_FUNC void report_error(format_func func, int error_code, + const char* message) noexcept { + memory_buffer full_message; + func(full_message, error_code, message); + // Don't use fwrite_fully because the latter may throw. + if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) + std::fputc('\n', stderr); +} + +// A wrapper around fwrite that throws on error. +inline void fwrite_fully(const void* ptr, size_t size, size_t count, + FILE* stream) { + size_t written = std::fwrite(ptr, size, count, stream); + if (written < count) + FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); +} + +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR +template +locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { + static_assert(std::is_same::value, ""); +} + +template Locale locale_ref::get() const { + static_assert(std::is_same::value, ""); + return locale_ ? *static_cast(locale_) : std::locale(); +} + +template +FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result { + auto& facet = std::use_facet>(loc.get()); + auto grouping = facet.grouping(); + auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); + return {std::move(grouping), thousands_sep}; +} +template FMT_FUNC Char decimal_point_impl(locale_ref loc) { + return std::use_facet>(loc.get()) + .decimal_point(); +} +#else +template +FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result { + return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR}; +} +template FMT_FUNC Char decimal_point_impl(locale_ref) { + return '.'; +} +#endif + +FMT_FUNC auto write_loc(appender out, loc_value value, + const format_specs<>& specs, locale_ref loc) -> bool { +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR + auto locale = loc.get(); + // We cannot use the num_put facet because it may produce output in + // a wrong encoding. + using facet = format_facet; + if (std::has_facet(locale)) + return std::use_facet(locale).put(out, value, specs); + return facet(locale).put(out, value, specs); +#endif + return false; +} +} // namespace detail + +template typename Locale::id format_facet::id; + +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR +template format_facet::format_facet(Locale& loc) { + auto& numpunct = std::use_facet>(loc); + grouping_ = numpunct.grouping(); + if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep()); +} + +template <> +FMT_API FMT_FUNC auto format_facet::do_put( + appender out, loc_value val, const format_specs<>& specs) const -> bool { + return val.visit( + detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); +} +#endif + +FMT_FUNC std::system_error vsystem_error(int error_code, string_view fmt, + format_args args) { + auto ec = std::error_code(error_code, std::generic_category()); + return std::system_error(ec, vformat(fmt, args)); +} + +namespace detail { + +template inline bool operator==(basic_fp x, basic_fp y) { + return x.f == y.f && x.e == y.e; +} + +// Compilers should be able to optimize this into the ror instruction. +FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept { + r &= 31; + return (n >> r) | (n << (32 - r)); +} +FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept { + r &= 63; + return (n >> r) | (n << (64 - r)); +} + +// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. +namespace dragonbox { +// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a +// 64-bit unsigned integer. +inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept { + return umul128_upper64(static_cast(x) << 32, y); +} + +// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a +// 128-bit unsigned integer. +inline uint128_fallback umul192_lower128(uint64_t x, + uint128_fallback y) noexcept { + uint64_t high = x * y.high(); + uint128_fallback high_low = umul128(x, y.low()); + return {high + high_low.high(), high_low.low()}; +} + +// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a +// 64-bit unsigned integer. +inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept { + return x * y; +} + +// Various fast log computations. +inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept { + FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); + return (e * 631305 - 261663) >> 21; +} + +FMT_INLINE_VARIABLE constexpr struct { + uint32_t divisor; + int shift_amount; +} div_small_pow10_infos[] = {{10, 16}, {100, 16}}; + +// Replaces n by floor(n / pow(10, N)) returning true if and only if n is +// divisible by pow(10, N). +// Precondition: n <= pow(10, N + 1). +template +bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept { + // The numbers below are chosen such that: + // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, + // 2. nm mod 2^k < m if and only if n is divisible by d, + // where m is magic_number, k is shift_amount + // and d is divisor. + // + // Item 1 is a common technique of replacing division by a constant with + // multiplication, see e.g. "Division by Invariant Integers Using + // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set + // to ceil(2^k/d) for large enough k. + // The idea for item 2 originates from Schubfach. + constexpr auto info = div_small_pow10_infos[N - 1]; + FMT_ASSERT(n <= info.divisor * 10, "n is too large"); + constexpr uint32_t magic_number = + (1u << info.shift_amount) / info.divisor + 1; + n *= magic_number; + const uint32_t comparison_mask = (1u << info.shift_amount) - 1; + bool result = (n & comparison_mask) < magic_number; + n >>= info.shift_amount; + return result; +} + +// Computes floor(n / pow(10, N)) for small n and N. +// Precondition: n <= pow(10, N + 1). +template uint32_t small_division_by_pow10(uint32_t n) noexcept { + constexpr auto info = div_small_pow10_infos[N - 1]; + FMT_ASSERT(n <= info.divisor * 10, "n is too large"); + constexpr uint32_t magic_number = + (1u << info.shift_amount) / info.divisor + 1; + return (n * magic_number) >> info.shift_amount; +} + +// Computes floor(n / 10^(kappa + 1)) (float) +inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept { + // 1374389535 = ceil(2^37/100) + return static_cast((static_cast(n) * 1374389535) >> 37); +} +// Computes floor(n / 10^(kappa + 1)) (double) +inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept { + // 2361183241434822607 = ceil(2^(64+7)/1000) + return umul128_upper64(n, 2361183241434822607ull) >> 7; +} + +// Various subroutines using pow10 cache +template struct cache_accessor; + +template <> struct cache_accessor { + using carrier_uint = float_info::carrier_uint; + using cache_entry_type = uint64_t; + + static uint64_t get_cached_power(int k) noexcept { + FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, + "k is out of range"); + static constexpr const uint64_t pow10_significands[] = { + 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, + 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, + 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, + 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, + 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, + 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, + 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff, + 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, + 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, + 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, + 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, + 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, + 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, + 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, + 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, + 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, + 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, + 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, + 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, + 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, + 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, + 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, + 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, + 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, + 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, + 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; + return pow10_significands[k - float_info::min_k]; + } + + struct compute_mul_result { + carrier_uint result; + bool is_integer; + }; + struct compute_mul_parity_result { + bool parity; + bool is_integer; + }; + + static compute_mul_result compute_mul( + carrier_uint u, const cache_entry_type& cache) noexcept { + auto r = umul96_upper64(u, cache); + return {static_cast(r >> 32), + static_cast(r) == 0}; + } + + static uint32_t compute_delta(const cache_entry_type& cache, + int beta) noexcept { + return static_cast(cache >> (64 - 1 - beta)); + } + + static compute_mul_parity_result compute_mul_parity( + carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { + FMT_ASSERT(beta >= 1, ""); + FMT_ASSERT(beta < 64, ""); + + auto r = umul96_lower64(two_f, cache); + return {((r >> (64 - beta)) & 1) != 0, + static_cast(r >> (32 - beta)) == 0}; + } + + static carrier_uint compute_left_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept { + return static_cast( + (cache - (cache >> (num_significand_bits() + 2))) >> + (64 - num_significand_bits() - 1 - beta)); + } + + static carrier_uint compute_right_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept { + return static_cast( + (cache + (cache >> (num_significand_bits() + 1))) >> + (64 - num_significand_bits() - 1 - beta)); + } + + static carrier_uint compute_round_up_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept { + return (static_cast( + cache >> (64 - num_significand_bits() - 2 - beta)) + + 1) / + 2; + } +}; + +template <> struct cache_accessor { + using carrier_uint = float_info::carrier_uint; + using cache_entry_type = uint128_fallback; + + static uint128_fallback get_cached_power(int k) noexcept { + FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, + "k is out of range"); + + static constexpr const uint128_fallback pow10_significands[] = { +#if FMT_USE_FULL_CACHE_DRAGONBOX + {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, + {0x9faacf3df73609b1, 0x77b191618c54e9ad}, + {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, + {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e}, + {0x9becce62836ac577, 0x4ee367f9430aec33}, + {0xc2e801fb244576d5, 0x229c41f793cda740}, + {0xf3a20279ed56d48a, 0x6b43527578c11110}, + {0x9845418c345644d6, 0x830a13896b78aaaa}, + {0xbe5691ef416bd60c, 0x23cc986bc656d554}, + {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9}, + {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa}, + {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54}, + {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69}, + {0x91376c36d99995be, 0x23100809b9c21fa2}, + {0xb58547448ffffb2d, 0xabd40a0c2832a78b}, + {0xe2e69915b3fff9f9, 0x16c90c8f323f516d}, + {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4}, + {0xb1442798f49ffb4a, 0x99cd11cfdf41779d}, + {0xdd95317f31c7fa1d, 0x40405643d711d584}, + {0x8a7d3eef7f1cfc52, 0x482835ea666b2573}, + {0xad1c8eab5ee43b66, 0xda3243650005eed0}, + {0xd863b256369d4a40, 0x90bed43e40076a83}, + {0x873e4f75e2224e68, 0x5a7744a6e804a292}, + {0xa90de3535aaae202, 0x711515d0a205cb37}, + {0xd3515c2831559a83, 0x0d5a5b44ca873e04}, + {0x8412d9991ed58091, 0xe858790afe9486c3}, + {0xa5178fff668ae0b6, 0x626e974dbe39a873}, + {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, + {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a}, + {0xa139029f6a239f72, 0x1c1fffc1ebc44e81}, + {0xc987434744ac874e, 0xa327ffb266b56221}, + {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9}, + {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa}, + {0xc4ce17b399107c22, 0xcb550fb4384d21d4}, + {0xf6019da07f549b2b, 0x7e2a53a146606a49}, + {0x99c102844f94e0fb, 0x2eda7444cbfc426e}, + {0xc0314325637a1939, 0xfa911155fefb5309}, + {0xf03d93eebc589f88, 0x793555ab7eba27cb}, + {0x96267c7535b763b5, 0x4bc1558b2f3458df}, + {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17}, + {0xea9c227723ee8bcb, 0x465e15a979c1cadd}, + {0x92a1958a7675175f, 0x0bfacd89ec191eca}, + {0xb749faed14125d36, 0xcef980ec671f667c}, + {0xe51c79a85916f484, 0x82b7e12780e7401b}, + {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811}, + {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16}, + {0xdfbdcece67006ac9, 0x67a791e093e1d49b}, + {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1}, + {0xaecc49914078536d, 0x58fae9f773886e19}, + {0xda7f5bf590966848, 0xaf39a475506a899f}, + {0x888f99797a5e012d, 0x6d8406c952429604}, + {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84}, + {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65}, + {0x855c3be0a17fcd26, 0x5cf2eea09a550680}, + {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, + {0xd0601d8efc57b08b, 0xf13b94daf124da27}, + {0x823c12795db6ce57, 0x76c53d08d6b70859}, + {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f}, + {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a}, + {0xfe5d54150b090b02, 0xd3f93b35435d7c4d}, + {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0}, + {0xc6b8e9b0709f109a, 0x359ab6419ca1091c}, + {0xf867241c8cc6d4c0, 0xc30163d203c94b63}, + {0x9b407691d7fc44f8, 0x79e0de63425dcf1e}, + {0xc21094364dfb5636, 0x985915fc12f542e5}, + {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e}, + {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43}, + {0xbd8430bd08277231, 0x50c6ff782a838354}, + {0xece53cec4a314ebd, 0xa4f8bf5635246429}, + {0x940f4613ae5ed136, 0x871b7795e136be9a}, + {0xb913179899f68584, 0x28e2557b59846e40}, + {0xe757dd7ec07426e5, 0x331aeada2fe589d0}, + {0x9096ea6f3848984f, 0x3ff0d2c85def7622}, + {0xb4bca50b065abe63, 0x0fed077a756b53aa}, + {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895}, + {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d}, + {0xb080392cc4349dec, 0xbd8d794d96aacfb4}, + {0xdca04777f541c567, 0xecf0d7a0fc5583a1}, + {0x89e42caaf9491b60, 0xf41686c49db57245}, + {0xac5d37d5b79b6239, 0x311c2875c522ced6}, + {0xd77485cb25823ac7, 0x7d633293366b828c}, + {0x86a8d39ef77164bc, 0xae5dff9c02033198}, + {0xa8530886b54dbdeb, 0xd9f57f830283fdfd}, + {0xd267caa862a12d66, 0xd072df63c324fd7c}, + {0x8380dea93da4bc60, 0x4247cb9e59f71e6e}, + {0xa46116538d0deb78, 0x52d9be85f074e609}, + {0xcd795be870516656, 0x67902e276c921f8c}, + {0x806bd9714632dff6, 0x00ba1cd8a3db53b7}, + {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5}, + {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce}, + {0xfad2a4b13d1b5d6c, 0x796b805720085f82}, + {0x9cc3a6eec6311a63, 0xcbe3303674053bb1}, + {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d}, + {0xf4f1b4d515acb93b, 0xee92fb5515482d45}, + {0x991711052d8bf3c5, 0x751bdd152d4d1c4b}, + {0xbf5cd54678eef0b6, 0xd262d45a78a0635e}, + {0xef340a98172aace4, 0x86fb897116c87c35}, + {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1}, + {0xbae0a846d2195712, 0x8974836059cca10a}, + {0xe998d258869facd7, 0x2bd1a438703fc94c}, + {0x91ff83775423cc06, 0x7b6306a34627ddd0}, + {0xb67f6455292cbf08, 0x1a3bc84c17b1d543}, + {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94}, + {0x8e938662882af53e, 0x547eb47b7282ee9d}, + {0xb23867fb2a35b28d, 0xe99e619a4f23aa44}, + {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5}, + {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05}, + {0xae0b158b4738705e, 0x9624ab50b148d446}, + {0xd98ddaee19068c76, 0x3badd624dd9b0958}, + {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7}, + {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d}, + {0xd47487cc8470652b, 0x7647c32000696720}, + {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074}, + {0xa5fb0a17c777cf09, 0xf468107100525891}, + {0xcf79cc9db955c2cc, 0x7182148d4066eeb5}, + {0x81ac1fe293d599bf, 0xc6f14cd848405531}, + {0xa21727db38cb002f, 0xb8ada00e5a506a7d}, + {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d}, + {0xfd442e4688bd304a, 0x908f4a166d1da664}, + {0x9e4a9cec15763e2e, 0x9a598e4e043287ff}, + {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe}, + {0xf7549530e188c128, 0xd12bee59e68ef47d}, + {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf}, + {0xc13a148e3032d6e7, 0xe36a52363c1faf02}, + {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2}, + {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba}, + {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8}, + {0xebdf661791d60f56, 0x111b495b3464ad22}, + {0x936b9fcebb25c995, 0xcab10dd900beec35}, + {0xb84687c269ef3bfb, 0x3d5d514f40eea743}, + {0xe65829b3046b0afa, 0x0cb4a5a3112a5113}, + {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac}, + {0xb3f4e093db73a093, 0x59ed216765690f57}, + {0xe0f218b8d25088b8, 0x306869c13ec3532d}, + {0x8c974f7383725573, 0x1e414218c73a13fc}, + {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, + {0xdbac6c247d62a583, 0xdf45f746b74abf3a}, + {0x894bc396ce5da772, 0x6b8bba8c328eb784}, + {0xab9eb47c81f5114f, 0x066ea92f3f326565}, + {0xd686619ba27255a2, 0xc80a537b0efefebe}, + {0x8613fd0145877585, 0xbd06742ce95f5f37}, + {0xa798fc4196e952e7, 0x2c48113823b73705}, + {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6}, + {0x82ef85133de648c4, 0x9a984d73dbe722fc}, + {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb}, + {0xcc963fee10b7d1b3, 0x318df905079926a9}, + {0xffbbcfe994e5c61f, 0xfdf17746497f7053}, + {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634}, + {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1}, + {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1}, + {0x9c1661a651213e2d, 0x06bea10ca65c084f}, + {0xc31bfa0fe5698db8, 0x486e494fcff30a63}, + {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb}, + {0x986ddb5c6b3a76b7, 0xf89629465a75e01d}, + {0xbe89523386091465, 0xf6bbb397f1135824}, + {0xee2ba6c0678b597f, 0x746aa07ded582e2d}, + {0x94db483840b717ef, 0xa8c2a44eb4571cdd}, + {0xba121a4650e4ddeb, 0x92f34d62616ce414}, + {0xe896a0d7e51e1566, 0x77b020baf9c81d18}, + {0x915e2486ef32cd60, 0x0ace1474dc1d122f}, + {0xb5b5ada8aaff80b8, 0x0d819992132456bb}, + {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a}, + {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, + {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3}, + {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf}, + {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c}, + {0xad4ab7112eb3929d, 0x86c16c98d2c953c7}, + {0xd89d64d57a607744, 0xe871c7bf077ba8b8}, + {0x87625f056c7c4a8b, 0x11471cd764ad4973}, + {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0}, + {0xd389b47879823479, 0x4aff1d108d4ec2c4}, + {0x843610cb4bf160cb, 0xcedf722a585139bb}, + {0xa54394fe1eedb8fe, 0xc2974eb4ee658829}, + {0xce947a3da6a9273e, 0x733d226229feea33}, + {0x811ccc668829b887, 0x0806357d5a3f5260}, + {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8}, + {0xc9bcff6034c13052, 0xfc89b393dd02f0b6}, + {0xfc2c3f3841f17c67, 0xbbac2078d443ace3}, + {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e}, + {0xc5029163f384a931, 0x0a9e795e65d4df12}, + {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6}, + {0x99ea0196163fa42e, 0x504bced1bf8e4e46}, + {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7}, + {0xf07da27a82c37088, 0x5d767327bb4e5a4d}, + {0x964e858c91ba2655, 0x3a6a07f8d510f870}, + {0xbbe226efb628afea, 0x890489f70a55368c}, + {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f}, + {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e}, + {0xb77ada0617e3bbcb, 0x09ce6ebb40173745}, + {0xe55990879ddcaabd, 0xcc420a6a101d0516}, + {0x8f57fa54c2a9eab6, 0x9fa946824a12232e}, + {0xb32df8e9f3546564, 0x47939822dc96abfa}, + {0xdff9772470297ebd, 0x59787e2b93bc56f8}, + {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b}, + {0xaefae51477a06b03, 0xede622920b6b23f2}, + {0xdab99e59958885c4, 0xe95fab368e45ecee}, + {0x88b402f7fd75539b, 0x11dbcb0218ebb415}, + {0xaae103b5fcd2a881, 0xd652bdc29f26a11a}, + {0xd59944a37c0752a2, 0x4be76d3346f04960}, + {0x857fcae62d8493a5, 0x6f70a4400c562ddc}, + {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953}, + {0xd097ad07a71f26b2, 0x7e2000a41346a7a8}, + {0x825ecc24c873782f, 0x8ed400668c0c28c9}, + {0xa2f67f2dfa90563b, 0x728900802f0f32fb}, + {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba}, + {0xfea126b7d78186bc, 0xe2f610c84987bfa9}, + {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca}, + {0xc6ede63fa05d3143, 0x91503d1c79720dbc}, + {0xf8a95fcf88747d94, 0x75a44c6397ce912b}, + {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb}, + {0xc24452da229b021b, 0xfbe85badce996169}, + {0xf2d56790ab41c2a2, 0xfae27299423fb9c4}, + {0x97c560ba6b0919a5, 0xdccd879fc967d41b}, + {0xbdb6b8e905cb600f, 0x5400e987bbc1c921}, + {0xed246723473e3813, 0x290123e9aab23b69}, + {0x9436c0760c86e30b, 0xf9a0b6720aaf6522}, + {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, + {0xe7958cb87392c2c2, 0xb60b1d1230b20e05}, + {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3}, + {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4}, + {0xe2280b6c20dd5232, 0x25c6da63c38de1b1}, + {0x8d590723948a535f, 0x579c487e5a38ad0f}, + {0xb0af48ec79ace837, 0x2d835a9df0c6d852}, + {0xdcdb1b2798182244, 0xf8e431456cf88e66}, + {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900}, + {0xac8b2d36eed2dac5, 0xe272467e3d222f40}, + {0xd7adf884aa879177, 0x5b0ed81dcc6abb10}, + {0x86ccbb52ea94baea, 0x98e947129fc2b4ea}, + {0xa87fea27a539e9a5, 0x3f2398d747b36225}, + {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae}, + {0x83a3eeeef9153e89, 0x1953cf68300424ad}, + {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8}, + {0xcdb02555653131b6, 0x3792f412cb06794e}, + {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1}, + {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5}, + {0xc8de047564d20a8b, 0xf245825a5a445276}, + {0xfb158592be068d2e, 0xeed6e2f0f0d56713}, + {0x9ced737bb6c4183d, 0x55464dd69685606c}, + {0xc428d05aa4751e4c, 0xaa97e14c3c26b887}, + {0xf53304714d9265df, 0xd53dd99f4b3066a9}, + {0x993fe2c6d07b7fab, 0xe546a8038efe402a}, + {0xbf8fdb78849a5f96, 0xde98520472bdd034}, + {0xef73d256a5c0f77c, 0x963e66858f6d4441}, + {0x95a8637627989aad, 0xdde7001379a44aa9}, + {0xbb127c53b17ec159, 0x5560c018580d5d53}, + {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7}, + {0x9226712162ab070d, 0xcab3961304ca70e9}, + {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23}, + {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b}, + {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243}, + {0xb267ed1940f1c61c, 0x55f038b237591ed4}, + {0xdf01e85f912e37a3, 0x6b6c46dec52f6689}, + {0x8b61313bbabce2c6, 0x2323ac4b3b3da016}, + {0xae397d8aa96c1b77, 0xabec975e0a0d081b}, + {0xd9c7dced53c72255, 0x96e7bd358c904a22}, + {0x881cea14545c7575, 0x7e50d64177da2e55}, + {0xaa242499697392d2, 0xdde50bd1d5d0b9ea}, + {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865}, + {0x84ec3c97da624ab4, 0xbd5af13bef0b113f}, + {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f}, + {0xcfb11ead453994ba, 0x67de18eda5814af3}, + {0x81ceb32c4b43fcf4, 0x80eacf948770ced8}, + {0xa2425ff75e14fc31, 0xa1258379a94d028e}, + {0xcad2f7f5359a3b3e, 0x096ee45813a04331}, + {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd}, + {0x9e74d1b791e07e48, 0x775ea264cf55347e}, + {0xc612062576589dda, 0x95364afe032a819e}, + {0xf79687aed3eec551, 0x3a83ddbd83f52205}, + {0x9abe14cd44753b52, 0xc4926a9672793543}, + {0xc16d9a0095928a27, 0x75b7053c0f178294}, + {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, + {0x971da05074da7bee, 0xd3f6fc16ebca5e04}, + {0xbce5086492111aea, 0x88f4bb1ca6bcf585}, + {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6}, + {0x9392ee8e921d5d07, 0x3aff322e62439fd0}, + {0xb877aa3236a4b449, 0x09befeb9fad487c3}, + {0xe69594bec44de15b, 0x4c2ebe687989a9b4}, + {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11}, + {0xb424dc35095cd80f, 0x538484c19ef38c95}, + {0xe12e13424bb40e13, 0x2865a5f206b06fba}, + {0x8cbccc096f5088cb, 0xf93f87b7442e45d4}, + {0xafebff0bcb24aafe, 0xf78f69a51539d749}, + {0xdbe6fecebdedd5be, 0xb573440e5a884d1c}, + {0x89705f4136b4a597, 0x31680a88f8953031}, + {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e}, + {0xd6bf94d5e57a42bc, 0x3d32907604691b4d}, + {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110}, + {0xa7c5ac471b478423, 0x0fcf80dc33721d54}, + {0xd1b71758e219652b, 0xd3c36113404ea4a9}, + {0x83126e978d4fdf3b, 0x645a1cac083126ea}, + {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4}, + {0xcccccccccccccccc, 0xcccccccccccccccd}, + {0x8000000000000000, 0x0000000000000000}, + {0xa000000000000000, 0x0000000000000000}, + {0xc800000000000000, 0x0000000000000000}, + {0xfa00000000000000, 0x0000000000000000}, + {0x9c40000000000000, 0x0000000000000000}, + {0xc350000000000000, 0x0000000000000000}, + {0xf424000000000000, 0x0000000000000000}, + {0x9896800000000000, 0x0000000000000000}, + {0xbebc200000000000, 0x0000000000000000}, + {0xee6b280000000000, 0x0000000000000000}, + {0x9502f90000000000, 0x0000000000000000}, + {0xba43b74000000000, 0x0000000000000000}, + {0xe8d4a51000000000, 0x0000000000000000}, + {0x9184e72a00000000, 0x0000000000000000}, + {0xb5e620f480000000, 0x0000000000000000}, + {0xe35fa931a0000000, 0x0000000000000000}, + {0x8e1bc9bf04000000, 0x0000000000000000}, + {0xb1a2bc2ec5000000, 0x0000000000000000}, + {0xde0b6b3a76400000, 0x0000000000000000}, + {0x8ac7230489e80000, 0x0000000000000000}, + {0xad78ebc5ac620000, 0x0000000000000000}, + {0xd8d726b7177a8000, 0x0000000000000000}, + {0x878678326eac9000, 0x0000000000000000}, + {0xa968163f0a57b400, 0x0000000000000000}, + {0xd3c21bcecceda100, 0x0000000000000000}, + {0x84595161401484a0, 0x0000000000000000}, + {0xa56fa5b99019a5c8, 0x0000000000000000}, + {0xcecb8f27f4200f3a, 0x0000000000000000}, + {0x813f3978f8940984, 0x4000000000000000}, + {0xa18f07d736b90be5, 0x5000000000000000}, + {0xc9f2c9cd04674ede, 0xa400000000000000}, + {0xfc6f7c4045812296, 0x4d00000000000000}, + {0x9dc5ada82b70b59d, 0xf020000000000000}, + {0xc5371912364ce305, 0x6c28000000000000}, + {0xf684df56c3e01bc6, 0xc732000000000000}, + {0x9a130b963a6c115c, 0x3c7f400000000000}, + {0xc097ce7bc90715b3, 0x4b9f100000000000}, + {0xf0bdc21abb48db20, 0x1e86d40000000000}, + {0x96769950b50d88f4, 0x1314448000000000}, + {0xbc143fa4e250eb31, 0x17d955a000000000}, + {0xeb194f8e1ae525fd, 0x5dcfab0800000000}, + {0x92efd1b8d0cf37be, 0x5aa1cae500000000}, + {0xb7abc627050305ad, 0xf14a3d9e40000000}, + {0xe596b7b0c643c719, 0x6d9ccd05d0000000}, + {0x8f7e32ce7bea5c6f, 0xe4820023a2000000}, + {0xb35dbf821ae4f38b, 0xdda2802c8a800000}, + {0xe0352f62a19e306e, 0xd50b2037ad200000}, + {0x8c213d9da502de45, 0x4526f422cc340000}, + {0xaf298d050e4395d6, 0x9670b12b7f410000}, + {0xdaf3f04651d47b4c, 0x3c0cdd765f114000}, + {0x88d8762bf324cd0f, 0xa5880a69fb6ac800}, + {0xab0e93b6efee0053, 0x8eea0d047a457a00}, + {0xd5d238a4abe98068, 0x72a4904598d6d880}, + {0x85a36366eb71f041, 0x47a6da2b7f864750}, + {0xa70c3c40a64e6c51, 0x999090b65f67d924}, + {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d}, + {0x82818f1281ed449f, 0xbff8f10e7a8921a5}, + {0xa321f2d7226895c7, 0xaff72d52192b6a0e}, + {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491}, + {0xfee50b7025c36a08, 0x02f236d04753d5b5}, + {0x9f4f2726179a2245, 0x01d762422c946591}, + {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6}, + {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3}, + {0x9b934c3b330c8577, 0x63cc55f49f88eb30}, + {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc}, + {0xf316271c7fc3908a, 0x8bef464e3945ef7b}, + {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad}, + {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318}, + {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde}, + {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b}, + {0xb975d6b6ee39e436, 0xb3e2fd538e122b45}, + {0xe7d34c64a9c85d44, 0x60dbbca87196b617}, + {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce}, + {0xb51d13aea4a488dd, 0x6babab6398bdbe42}, + {0xe264589a4dcdab14, 0xc696963c7eed2dd2}, + {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3}, + {0xb0de65388cc8ada8, 0x3b25a55f43294bcc}, + {0xdd15fe86affad912, 0x49ef0eb713f39ebf}, + {0x8a2dbf142dfcc7ab, 0x6e3569326c784338}, + {0xacb92ed9397bf996, 0x49c2c37f07965405}, + {0xd7e77a8f87daf7fb, 0xdc33745ec97be907}, + {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4}, + {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d}, + {0xd2d80db02aabd62b, 0xf50a3fa490c30191}, + {0x83c7088e1aab65db, 0x792667c6da79e0fb}, + {0xa4b8cab1a1563f52, 0x577001b891185939}, + {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, + {0x80b05e5ac60b6178, 0x544f8158315b05b5}, + {0xa0dc75f1778e39d6, 0x696361ae3db1c722}, + {0xc913936dd571c84c, 0x03bc3a19cd1e38ea}, + {0xfb5878494ace3a5f, 0x04ab48a04065c724}, + {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77}, + {0xc45d1df942711d9a, 0x3ba5d0bd324f8395}, + {0xf5746577930d6500, 0xca8f44ec7ee3647a}, + {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc}, + {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f}, + {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f}, + {0x95d04aee3b80ece5, 0xbba1f1d158724a13}, + {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98}, + {0xea1575143cf97226, 0xf52d09d71a3293be}, + {0x924d692ca61be758, 0x593c2626705f9c57}, + {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d}, + {0xe498f455c38b997a, 0x0b6dfb9c0f956448}, + {0x8edf98b59a373fec, 0x4724bd4189bd5ead}, + {0xb2977ee300c50fe7, 0x58edec91ec2cb658}, + {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee}, + {0x8b865b215899f46c, 0xbd79e0d20082ee75}, + {0xae67f1e9aec07187, 0xecd8590680a3aa12}, + {0xda01ee641a708de9, 0xe80e6f4820cc9496}, + {0x884134fe908658b2, 0x3109058d147fdcde}, + {0xaa51823e34a7eede, 0xbd4b46f0599fd416}, + {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b}, + {0x850fadc09923329e, 0x03e2cf6bc604ddb1}, + {0xa6539930bf6bff45, 0x84db8346b786151d}, + {0xcfe87f7cef46ff16, 0xe612641865679a64}, + {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f}, + {0xa26da3999aef7749, 0xe3be5e330f38f09e}, + {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6}, + {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7}, + {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb}, + {0xc646d63501a1511d, 0xb281e1fd541501b9}, + {0xf7d88bc24209a565, 0x1f225a7ca91a4227}, + {0x9ae757596946075f, 0x3375788de9b06959}, + {0xc1a12d2fc3978937, 0x0052d6b1641c83af}, + {0xf209787bb47d6b84, 0xc0678c5dbd23a49b}, + {0x9745eb4d50ce6332, 0xf840b7ba963646e1}, + {0xbd176620a501fbff, 0xb650e5a93bc3d899}, + {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf}, + {0x93ba47c980e98cdf, 0xc66f336c36b10138}, + {0xb8a8d9bbe123f017, 0xb80b0047445d4185}, + {0xe6d3102ad96cec1d, 0xa60dc059157491e6}, + {0x9043ea1ac7e41392, 0x87c89837ad68db30}, + {0xb454e4a179dd1877, 0x29babe4598c311fc}, + {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b}, + {0x8ce2529e2734bb1d, 0x1899e4a65f58660d}, + {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90}, + {0xdc21a1171d42645d, 0x76707543f4fa1f74}, + {0x899504ae72497eba, 0x6a06494a791c53a9}, + {0xabfa45da0edbde69, 0x0487db9d17636893}, + {0xd6f8d7509292d603, 0x45a9d2845d3c42b7}, + {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, + {0xa7f26836f282b732, 0x8e6cac7768d7141f}, + {0xd1ef0244af2364ff, 0x3207d795430cd927}, + {0x8335616aed761f1f, 0x7f44e6bd49e807b9}, + {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7}, + {0xcd036837130890a1, 0x36dba887c37a8c10}, + {0x802221226be55a64, 0xc2494954da2c978a}, + {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d}, + {0xc83553c5c8965d3d, 0x6f92829494e5acc8}, + {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa}, + {0x9c69a97284b578d7, 0xff2a760414536efc}, + {0xc38413cf25e2d70d, 0xfef5138519684abb}, + {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a}, + {0x98bf2f79d5993802, 0xef2f773ffbd97a62}, + {0xbeeefb584aff8603, 0xaafb550ffacfd8fb}, + {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39}, + {0x952ab45cfa97a0b2, 0xdd945a747bf26184}, + {0xba756174393d88df, 0x94f971119aeef9e5}, + {0xe912b9d1478ceb17, 0x7a37cd5601aab85e}, + {0x91abb422ccb812ee, 0xac62e055c10ab33b}, + {0xb616a12b7fe617aa, 0x577b986b314d600a}, + {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c}, + {0x8e41ade9fbebc27d, 0x14588f13be847308}, + {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9}, + {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc}, + {0x8aec23d680043bee, 0x25de7bb9480d5855}, + {0xada72ccc20054ae9, 0xaf561aa79a10ae6b}, + {0xd910f7ff28069da4, 0x1b2ba1518094da05}, + {0x87aa9aff79042286, 0x90fb44d2f05d0843}, + {0xa99541bf57452b28, 0x353a1607ac744a54}, + {0xd3fa922f2d1675f2, 0x42889b8997915ce9}, + {0x847c9b5d7c2e09b7, 0x69956135febada12}, + {0xa59bc234db398c25, 0x43fab9837e699096}, + {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc}, + {0x8161afb94b44f57d, 0x1d1be0eebac278f6}, + {0xa1ba1ba79e1632dc, 0x6462d92a69731733}, + {0xca28a291859bbf93, 0x7d7b8f7503cfdcff}, + {0xfcb2cb35e702af78, 0x5cda735244c3d43f}, + {0x9defbf01b061adab, 0x3a0888136afa64a8}, + {0xc56baec21c7a1916, 0x088aaa1845b8fdd1}, + {0xf6c69a72a3989f5b, 0x8aad549e57273d46}, + {0x9a3c2087a63f6399, 0x36ac54e2f678864c}, + {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de}, + {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6}, + {0x969eb7c47859e743, 0x9f644ae5a4b1b326}, + {0xbc4665b596706114, 0x873d5d9f0dde1fef}, + {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb}, + {0x9316ff75dd87cbd8, 0x09a7f12442d588f3}, + {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30}, + {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb}, + {0x8fa475791a569d10, 0xf96e017d694487bd}, + {0xb38d92d760ec4455, 0x37c981dcc395a9ad}, + {0xe070f78d3927556a, 0x85bbe253f47b1418}, + {0x8c469ab843b89562, 0x93956d7478ccec8f}, + {0xaf58416654a6babb, 0x387ac8d1970027b3}, + {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f}, + {0x88fcf317f22241e2, 0x441fece3bdf81f04}, + {0xab3c2fddeeaad25a, 0xd527e81cad7626c4}, + {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075}, + {0x85c7056562757456, 0xf6872d5667844e4a}, + {0xa738c6bebb12d16c, 0xb428f8ac016561dc}, + {0xd106f86e69d785c7, 0xe13336d701beba53}, + {0x82a45b450226b39c, 0xecc0024661173474}, + {0xa34d721642b06084, 0x27f002d7f95d0191}, + {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5}, + {0xff290242c83396ce, 0x7e67047175a15272}, + {0x9f79a169bd203e41, 0x0f0062c6e984d387}, + {0xc75809c42c684dd1, 0x52c07b78a3e60869}, + {0xf92e0c3537826145, 0xa7709a56ccdf8a83}, + {0x9bbcc7a142b17ccb, 0x88a66076400bb692}, + {0xc2abf989935ddbfe, 0x6acff893d00ea436}, + {0xf356f7ebf83552fe, 0x0583f6b8c4124d44}, + {0x98165af37b2153de, 0xc3727a337a8b704b}, + {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d}, + {0xeda2ee1c7064130c, 0x1162def06f79df74}, + {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9}, + {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693}, + {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438}, + {0x910ab1d4db9914a0, 0x1d9c9892400a22a3}, + {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c}, + {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e}, + {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, + {0xb10d8e1456105dad, 0x7425a83e872c5f48}, + {0xdd50f1996b947518, 0xd12f124e28f7771a}, + {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70}, + {0xace73cbfdc0bfb7b, 0x636cc64d1001550c}, + {0xd8210befd30efa5a, 0x3c47f7e05401aa4f}, + {0x8714a775e3e95c78, 0x65acfaec34810a72}, + {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e}, + {0xd31045a8341ca07c, 0x1ede48111209a051}, + {0x83ea2b892091e44d, 0x934aed0aab460433}, + {0xa4e4b66b68b65d60, 0xf81da84d56178540}, + {0xce1de40642e3f4b9, 0x36251260ab9d668f}, + {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a}, + {0xa1075a24e4421730, 0xb24cf65b8612f820}, + {0xc94930ae1d529cfc, 0xdee033f26797b628}, + {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2}, + {0x9d412e0806e88aa5, 0x8e1f289560ee864f}, + {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3}, + {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc}, + {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a}, + {0xbff610b0cc6edd3f, 0x17fd090a58d32af4}, + {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1}, + {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f}, + {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2}, + {0xea53df5fd18d5513, 0x84c86189216dc5ee}, + {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5}, + {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2}, + {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, + {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f}, + {0xb2c71d5bca9023f8, 0x743e20e9ef511013}, + {0xdf78e4b2bd342cf6, 0x914da9246b255417}, + {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f}, + {0xae9672aba3d0c320, 0xa184ac2473b529b2}, + {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f}, + {0x8865899617fb1871, 0x7e2fa67c7a658893}, + {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8}, + {0xd51ea6fa85785631, 0x552a74227f3ea566}, + {0x8533285c936b35de, 0xd53a88958f872760}, + {0xa67ff273b8460356, 0x8a892abaf368f138}, + {0xd01fef10a657842c, 0x2d2b7569b0432d86}, + {0x8213f56a67f6b29b, 0x9c3b29620e29fc74}, + {0xa298f2c501f45f42, 0x8349f3ba91b47b90}, + {0xcb3f2f7642717713, 0x241c70a936219a74}, + {0xfe0efb53d30dd4d7, 0xed238cd383aa0111}, + {0x9ec95d1463e8a506, 0xf4363804324a40ab}, + {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6}, + {0xf81aa16fdc1b81da, 0xdd94b7868e94050b}, + {0x9b10a4e5e9913128, 0xca7cf2b4191c8327}, + {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1}, + {0xf24a01a73cf2dccf, 0xbc633b39673c8ced}, + {0x976e41088617ca01, 0xd5be0503e085d814}, + {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19}, + {0xec9c459d51852ba2, 0xddf8e7d60ed1219f}, + {0x93e1ab8252f33b45, 0xcabb90e5c942b504}, + {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, + {0xe7109bfba19c0c9d, 0x0cc512670a783ad5}, + {0x906a617d450187e2, 0x27fb2b80668b24c6}, + {0xb484f9dc9641e9da, 0xb1f9f660802dedf7}, + {0xe1a63853bbd26451, 0x5e7873f8a0396974}, + {0x8d07e33455637eb2, 0xdb0b487b6423e1e9}, + {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63}, + {0xdc5c5301c56b75f7, 0x7641a140cc7810fc}, + {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e}, + {0xac2820d9623bf429, 0x546345fa9fbdcd45}, + {0xd732290fbacaf133, 0xa97c177947ad4096}, + {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e}, + {0xa81f301449ee8c70, 0x5c68f256bfff5a75}, + {0xd226fc195c6a2f8c, 0x73832eec6fff3112}, + {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac}, + {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56}, + {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec}, + {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4}, + {0xa0555e361951c366, 0xd7e105bcc3326220}, + {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8}, + {0xfa856334878fc150, 0xb14f98f6f0feb952}, + {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4}, + {0xc3b8358109e84f07, 0x0a862f80ec4700c9}, + {0xf4a642e14c6262c8, 0xcd27bb612758c0fb}, + {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d}, + {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4}, + {0xeeea5d5004981478, 0x1858ccfce06cac75}, + {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, + {0xbaa718e68396cffd, 0xd30560258f54e6bb}, + {0xe950df20247c83fd, 0x47c6b82ef32a206a}, + {0x91d28b7416cdd27e, 0x4cdc331d57fa5442}, + {0xb6472e511c81471d, 0xe0133fe4adf8e953}, + {0xe3d8f9e563a198e5, 0x58180fddd97723a7}, + {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649}, + {0xb201833b35d63f73, 0x2cd2cc6551e513db}, + {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2}, + {0x8b112e86420f6191, 0xfb04afaf27faf783}, + {0xadd57a27d29339f6, 0x79c5db9af1f9b564}, + {0xd94ad8b1c7380874, 0x18375281ae7822bd}, + {0x87cec76f1c830548, 0x8f2293910d0b15b6}, + {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23}, + {0xd433179d9c8cb841, 0x5fa60692a46151ec}, + {0x849feec281d7f328, 0xdbc7c41ba6bcd334}, + {0xa5c7ea73224deff3, 0x12b9b522906c0801}, + {0xcf39e50feae16bef, 0xd768226b34870a01}, + {0x81842f29f2cce375, 0xe6a1158300d46641}, + {0xa1e53af46f801c53, 0x60495ae3c1097fd1}, + {0xca5e89b18b602368, 0x385bb19cb14bdfc5}, + {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, + {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, + {0xc5a05277621be293, 0xc7098b7305241886}, + {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}, + {0x9a65406d44a5c903, 0x737f74f1dc043329}, + {0xc0fe908895cf3b44, 0x505f522e53053ff3}, + {0xf13e34aabb430a15, 0x647726b9e7c68ff0}, + {0x96c6e0eab509e64d, 0x5eca783430dc19f6}, + {0xbc789925624c5fe0, 0xb67d16413d132073}, + {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890}, + {0x933e37a534cbaae7, 0x8e91b962f7b6f15a}, + {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1}, + {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d}, + {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2}, + {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e}, + {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, + {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, + {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, + { 0xdb68c2ca82ed2a05, + 0xa67398db9f6820e2 } +#else + {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, + {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, + {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, + {0x86a8d39ef77164bc, 0xae5dff9c02033198}, + {0xd98ddaee19068c76, 0x3badd624dd9b0958}, + {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, + {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, + {0xe55990879ddcaabd, 0xcc420a6a101d0516}, + {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, + {0x95a8637627989aad, 0xdde7001379a44aa9}, + {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, + {0xc350000000000000, 0x0000000000000000}, + {0x9dc5ada82b70b59d, 0xf020000000000000}, + {0xfee50b7025c36a08, 0x02f236d04753d5b5}, + {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, + {0xa6539930bf6bff45, 0x84db8346b786151d}, + {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, + {0xd910f7ff28069da4, 0x1b2ba1518094da05}, + {0xaf58416654a6babb, 0x387ac8d1970027b3}, + {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, + {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, + {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, + {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, + {0xf13e34aabb430a15, 0x647726b9e7c68ff0} +#endif + }; + +#if FMT_USE_FULL_CACHE_DRAGONBOX + return pow10_significands[k - float_info::min_k]; +#else + static constexpr const uint64_t powers_of_5_64[] = { + 0x0000000000000001, 0x0000000000000005, 0x0000000000000019, + 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35, + 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, + 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd, + 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9, + 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5, + 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, + 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed, + 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9}; + + static const int compression_ratio = 27; + + // Compute base index. + int cache_index = (k - float_info::min_k) / compression_ratio; + int kb = cache_index * compression_ratio + float_info::min_k; + int offset = k - kb; + + // Get base cache. + uint128_fallback base_cache = pow10_significands[cache_index]; + if (offset == 0) return base_cache; + + // Compute the required amount of bit-shift. + int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; + FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); + + // Try to recover the real cache. + uint64_t pow5 = powers_of_5_64[offset]; + uint128_fallback recovered_cache = umul128(base_cache.high(), pow5); + uint128_fallback middle_low = umul128(base_cache.low(), pow5); + + recovered_cache += middle_low.high(); + + uint64_t high_to_middle = recovered_cache.high() << (64 - alpha); + uint64_t middle_to_low = recovered_cache.low() << (64 - alpha); + + recovered_cache = + uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, + ((middle_low.low() >> alpha) | middle_to_low)}; + FMT_ASSERT(recovered_cache.low() + 1 != 0, ""); + return {recovered_cache.high(), recovered_cache.low() + 1}; +#endif + } + + struct compute_mul_result { + carrier_uint result; + bool is_integer; + }; + struct compute_mul_parity_result { + bool parity; + bool is_integer; + }; + + static compute_mul_result compute_mul( + carrier_uint u, const cache_entry_type& cache) noexcept { + auto r = umul192_upper128(u, cache); + return {r.high(), r.low() == 0}; + } + + static uint32_t compute_delta(cache_entry_type const& cache, + int beta) noexcept { + return static_cast(cache.high() >> (64 - 1 - beta)); + } + + static compute_mul_parity_result compute_mul_parity( + carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept { + FMT_ASSERT(beta >= 1, ""); + FMT_ASSERT(beta < 64, ""); + + auto r = umul192_lower128(two_f, cache); + return {((r.high() >> (64 - beta)) & 1) != 0, + ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; + } + + static carrier_uint compute_left_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept { + return (cache.high() - + (cache.high() >> (num_significand_bits() + 2))) >> + (64 - num_significand_bits() - 1 - beta); + } + + static carrier_uint compute_right_endpoint_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept { + return (cache.high() + + (cache.high() >> (num_significand_bits() + 1))) >> + (64 - num_significand_bits() - 1 - beta); + } + + static carrier_uint compute_round_up_for_shorter_interval_case( + const cache_entry_type& cache, int beta) noexcept { + return ((cache.high() >> (64 - num_significand_bits() - 2 - beta)) + + 1) / + 2; + } +}; + +FMT_FUNC uint128_fallback get_cached_power(int k) noexcept { + return cache_accessor::get_cached_power(k); +} + +// Various integer checks +template +bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept { + const int case_shorter_interval_left_endpoint_lower_threshold = 2; + const int case_shorter_interval_left_endpoint_upper_threshold = 3; + return exponent >= case_shorter_interval_left_endpoint_lower_threshold && + exponent <= case_shorter_interval_left_endpoint_upper_threshold; +} + +// Remove trailing zeros from n and return the number of zeros removed (float) +FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept { + FMT_ASSERT(n != 0, ""); + // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. + constexpr uint32_t mod_inv_5 = 0xcccccccd; + constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 + + while (true) { + auto q = rotr(n * mod_inv_25, 2); + if (q > max_value() / 100) break; + n = q; + s += 2; + } + auto q = rotr(n * mod_inv_5, 1); + if (q <= max_value() / 10) { + n = q; + s |= 1; + } + return s; +} + +// Removes trailing zeros and returns the number of zeros removed (double) +FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept { + FMT_ASSERT(n != 0, ""); + + // This magic number is ceil(2^90 / 10^8). + constexpr uint64_t magic_number = 12379400392853802749ull; + auto nm = umul128(n, magic_number); + + // Is n is divisible by 10^8? + if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) { + // If yes, work with the quotient... + auto n32 = static_cast(nm.high() >> (90 - 64)); + // ... and use the 32 bit variant of the function + int s = remove_trailing_zeros(n32, 8); + n = n32; + return s; + } + + // If n is not divisible by 10^8, work with n itself. + constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; + constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // = mod_inv_5 * mod_inv_5 + + int s = 0; + while (true) { + auto q = rotr(n * mod_inv_25, 2); + if (q > max_value() / 100) break; + n = q; + s += 2; + } + auto q = rotr(n * mod_inv_5, 1); + if (q <= max_value() / 10) { + n = q; + s |= 1; + } + + return s; +} + +// The main algorithm for shorter interval case +template +FMT_INLINE decimal_fp shorter_interval_case(int exponent) noexcept { + decimal_fp ret_value; + // Compute k and beta + const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); + const int beta = exponent + floor_log2_pow10(-minus_k); + + // Compute xi and zi + using cache_entry_type = typename cache_accessor::cache_entry_type; + const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); + + auto xi = cache_accessor::compute_left_endpoint_for_shorter_interval_case( + cache, beta); + auto zi = cache_accessor::compute_right_endpoint_for_shorter_interval_case( + cache, beta); + + // If the left endpoint is not an integer, increase it + if (!is_left_endpoint_integer_shorter_interval(exponent)) ++xi; + + // Try bigger divisor + ret_value.significand = zi / 10; + + // If succeed, remove trailing zeros if necessary and return + if (ret_value.significand * 10 >= xi) { + ret_value.exponent = minus_k + 1; + ret_value.exponent += remove_trailing_zeros(ret_value.significand); + return ret_value; + } + + // Otherwise, compute the round-up of y + ret_value.significand = + cache_accessor::compute_round_up_for_shorter_interval_case(cache, + beta); + ret_value.exponent = minus_k; + + // When tie occurs, choose one of them according to the rule + if (exponent >= float_info::shorter_interval_tie_lower_threshold && + exponent <= float_info::shorter_interval_tie_upper_threshold) { + ret_value.significand = ret_value.significand % 2 == 0 + ? ret_value.significand + : ret_value.significand - 1; + } else if (ret_value.significand < xi) { + ++ret_value.significand; + } + return ret_value; +} + +template decimal_fp to_decimal(T x) noexcept { + // Step 1: integer promotion & Schubfach multiplier calculation. + + using carrier_uint = typename float_info::carrier_uint; + using cache_entry_type = typename cache_accessor::cache_entry_type; + auto br = bit_cast(x); + + // Extract significand bits and exponent bits. + const carrier_uint significand_mask = + (static_cast(1) << num_significand_bits()) - 1; + carrier_uint significand = (br & significand_mask); + int exponent = + static_cast((br & exponent_mask()) >> num_significand_bits()); + + if (exponent != 0) { // Check if normal. + exponent -= exponent_bias() + num_significand_bits(); + + // Shorter interval case; proceed like Schubfach. + // In fact, when exponent == 1 and significand == 0, the interval is + // regular. However, it can be shown that the end-results are anyway same. + if (significand == 0) return shorter_interval_case(exponent); + + significand |= (static_cast(1) << num_significand_bits()); + } else { + // Subnormal case; the interval is always regular. + if (significand == 0) return {0, 0}; + exponent = + std::numeric_limits::min_exponent - num_significand_bits() - 1; + } + + const bool include_left_endpoint = (significand % 2 == 0); + const bool include_right_endpoint = include_left_endpoint; + + // Compute k and beta. + const int minus_k = floor_log10_pow2(exponent) - float_info::kappa; + const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); + const int beta = exponent + floor_log2_pow10(-minus_k); + + // Compute zi and deltai. + // 10^kappa <= deltai < 10^(kappa + 1) + const uint32_t deltai = cache_accessor::compute_delta(cache, beta); + const carrier_uint two_fc = significand << 1; + + // For the case of binary32, the result of integer check is not correct for + // 29711844 * 2^-82 + // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18 + // and 29711844 * 2^-81 + // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17, + // and they are the unique counterexamples. However, since 29711844 is even, + // this does not cause any problem for the endpoints calculations; it can only + // cause a problem when we need to perform integer check for the center. + // Fortunately, with these inputs, that branch is never executed, so we are + // fine. + const typename cache_accessor::compute_mul_result z_mul = + cache_accessor::compute_mul((two_fc | 1) << beta, cache); + + // Step 2: Try larger divisor; remove trailing zeros if necessary. + + // Using an upper bound on zi, we might be able to optimize the division + // better than the compiler; we are computing zi / big_divisor here. + decimal_fp ret_value; + ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result); + uint32_t r = static_cast(z_mul.result - float_info::big_divisor * + ret_value.significand); + + if (r < deltai) { + // Exclude the right endpoint if necessary. + if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) { + --ret_value.significand; + r = float_info::big_divisor; + goto small_divisor_case_label; + } + } else if (r > deltai) { + goto small_divisor_case_label; + } else { + // r == deltai; compare fractional parts. + const typename cache_accessor::compute_mul_parity_result x_mul = + cache_accessor::compute_mul_parity(two_fc - 1, cache, beta); + + if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint))) + goto small_divisor_case_label; + } + ret_value.exponent = minus_k + float_info::kappa + 1; + + // We may need to remove trailing zeros. + ret_value.exponent += remove_trailing_zeros(ret_value.significand); + return ret_value; + + // Step 3: Find the significand with the smaller divisor. + +small_divisor_case_label: + ret_value.significand *= 10; + ret_value.exponent = minus_k + float_info::kappa; + + uint32_t dist = r - (deltai / 2) + (float_info::small_divisor / 2); + const bool approx_y_parity = + ((dist ^ (float_info::small_divisor / 2)) & 1) != 0; + + // Is dist divisible by 10^kappa? + const bool divisible_by_small_divisor = + check_divisibility_and_divide_by_pow10::kappa>(dist); + + // Add dist / 10^kappa to the significand. + ret_value.significand += dist; + + if (!divisible_by_small_divisor) return ret_value; + + // Check z^(f) >= epsilon^(f). + // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1, + // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f). + // Since there are only 2 possibilities, we only need to care about the + // parity. Also, zi and r should have the same parity since the divisor + // is an even number. + const auto y_mul = cache_accessor::compute_mul_parity(two_fc, cache, beta); + + // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f), + // or equivalently, when y is an integer. + if (y_mul.parity != approx_y_parity) + --ret_value.significand; + else if (y_mul.is_integer & (ret_value.significand % 2 != 0)) + --ret_value.significand; + return ret_value; +} +} // namespace dragonbox +} // namespace detail + +template <> struct formatter { + FMT_CONSTEXPR auto parse(format_parse_context& ctx) + -> format_parse_context::iterator { + return ctx.begin(); + } + + auto format(const detail::bigint& n, format_context& ctx) const + -> format_context::iterator { + auto out = ctx.out(); + bool first = true; + for (auto i = n.bigits_.size(); i > 0; --i) { + auto value = n.bigits_[i - 1u]; + if (first) { + out = format_to(out, FMT_STRING("{:x}"), value); + first = false; + continue; + } + out = format_to(out, FMT_STRING("{:08x}"), value); + } + if (n.exp_ > 0) + out = format_to(out, FMT_STRING("p{}"), + n.exp_ * detail::bigint::bigit_bits); + return out; + } +}; + +FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { + for_each_codepoint(s, [this](uint32_t cp, string_view) { + if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8")); + if (cp <= 0xFFFF) { + buffer_.push_back(static_cast(cp)); + } else { + cp -= 0x10000; + buffer_.push_back(static_cast(0xD800 + (cp >> 10))); + buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF))); + } + return true; + }); + buffer_.push_back(0); +} + +FMT_FUNC void format_system_error(detail::buffer& out, int error_code, + const char* message) noexcept { + FMT_TRY { + auto ec = std::error_code(error_code, std::generic_category()); + write(std::back_inserter(out), std::system_error(ec, message).what()); + return; + } + FMT_CATCH(...) {} + format_error_code(out, error_code, message); +} + +FMT_FUNC void report_system_error(int error_code, + const char* message) noexcept { + report_error(format_system_error, error_code, message); +} + +FMT_FUNC std::string vformat(string_view fmt, format_args args) { + // Don't optimize the "{}" case to keep the binary size small and because it + // can be better optimized in fmt::format anyway. + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, args); + return to_string(buffer); +} + +namespace detail { +#ifndef _WIN32 +FMT_FUNC bool write_console(std::FILE*, string_view) { return false; } +#else +using dword = conditional_t; +extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // + void*, const void*, dword, dword*, void*); + +FMT_FUNC bool write_console(std::FILE* f, string_view text) { + auto fd = _fileno(f); + if (!_isatty(fd)) return false; + auto u16 = utf8_to_utf16(text); + auto written = dword(); + return WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)), u16.c_str(), + static_cast(u16.size()), &written, nullptr) != 0; +} + +// Print assuming legacy (non-Unicode) encoding. +FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) { + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, + basic_format_args>(args)); + fwrite_fully(buffer.data(), 1, buffer.size(), f); +} +#endif + +FMT_FUNC void print(std::FILE* f, string_view text) { + if (!write_console(f, text)) fwrite_fully(text.data(), 1, text.size(), f); +} +} // namespace detail + +FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { + auto buffer = memory_buffer(); + detail::vformat_to(buffer, fmt, args); + detail::print(f, {buffer.data(), buffer.size()}); +} + +FMT_FUNC void vprint(string_view fmt, format_args args) { + vprint(stdout, fmt, args); +} + +namespace detail { + +struct singleton { + unsigned char upper; + unsigned char lower_count; +}; + +inline auto is_printable(uint16_t x, const singleton* singletons, + size_t singletons_size, + const unsigned char* singleton_lowers, + const unsigned char* normal, size_t normal_size) + -> bool { + auto upper = x >> 8; + auto lower_start = 0; + for (size_t i = 0; i < singletons_size; ++i) { + auto s = singletons[i]; + auto lower_end = lower_start + s.lower_count; + if (upper < s.upper) break; + if (upper == s.upper) { + for (auto j = lower_start; j < lower_end; ++j) { + if (singleton_lowers[j] == (x & 0xff)) return false; + } + } + lower_start = lower_end; + } + + auto xsigned = static_cast(x); + auto current = true; + for (size_t i = 0; i < normal_size; ++i) { + auto v = static_cast(normal[i]); + auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v; + xsigned -= len; + if (xsigned < 0) break; + current = !current; + } + return current; +} + +// This code is generated by support/printable.py. +FMT_FUNC auto is_printable(uint32_t cp) -> bool { + static constexpr singleton singletons0[] = { + {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, + {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, + {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5}, + {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22}, + {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3}, + {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8}, + {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9}, + }; + static constexpr unsigned char singletons0_lower[] = { + 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90, + 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f, + 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1, + 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04, + 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d, + 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, + 0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, + 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, + 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d, + 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d, + 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, + 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7, + 0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, + 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7, + 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, + 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e, + 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, + 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e, + 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, + 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, + 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0, + 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, + 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, + 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, + 0xfe, 0xff, + }; + static constexpr singleton singletons1[] = { + {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2}, + {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5}, + {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5}, + {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2}, + {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5}, + {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2}, + {0xfa, 2}, {0xfb, 1}, + }; + static constexpr unsigned char singletons1_lower[] = { + 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07, + 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36, + 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87, + 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, + 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b, + 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9, + 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66, + 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, + 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc, + 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, + 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6, + 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c, + 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, + 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, + 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93, + }; + static constexpr unsigned char normal0[] = { + 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04, + 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0, + 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01, + 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03, + 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03, + 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a, + 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15, + 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f, + 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80, + 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07, + 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06, + 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04, + 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac, + 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c, + 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11, + 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c, + 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b, + 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6, + 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03, + 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80, + 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06, + 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c, + 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17, + 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80, + 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80, + 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d, + }; + static constexpr unsigned char normal1[] = { + 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f, + 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e, + 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04, + 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09, + 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16, + 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f, + 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36, + 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33, + 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08, + 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e, + 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41, + 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03, + 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22, + 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04, + 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45, + 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03, + 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81, + 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75, + 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1, + 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a, + 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11, + 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09, + 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89, + 0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6, + 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09, + 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50, + 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05, + 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83, + 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05, + 0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80, + 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80, + 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07, + 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e, + 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07, + 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06, + }; + auto lower = static_cast(cp); + if (cp < 0x10000) { + return is_printable(lower, singletons0, + sizeof(singletons0) / sizeof(*singletons0), + singletons0_lower, normal0, sizeof(normal0)); + } + if (cp < 0x20000) { + return is_printable(lower, singletons1, + sizeof(singletons1) / sizeof(*singletons1), + singletons1_lower, normal1, sizeof(normal1)); + } + if (0x2a6de <= cp && cp < 0x2a700) return false; + if (0x2b735 <= cp && cp < 0x2b740) return false; + if (0x2b81e <= cp && cp < 0x2b820) return false; + if (0x2cea2 <= cp && cp < 0x2ceb0) return false; + if (0x2ebe1 <= cp && cp < 0x2f800) return false; + if (0x2fa1e <= cp && cp < 0x30000) return false; + if (0x3134b <= cp && cp < 0xe0100) return false; + if (0xe01f0 <= cp && cp < 0x110000) return false; + return cp < 0x110000; +} + +} // namespace detail + +FMT_END_NAMESPACE + +#endif // FMT_FORMAT_INL_H_ diff --git a/include/fmt/format.h b/include/fmt/format.h new file mode 100644 index 0000000..c78364a --- /dev/null +++ b/include/fmt/format.h @@ -0,0 +1,4725 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - present, Victor Zverovich + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + --- Optional exception to the license --- + + As an exception, if, as a result of your compiling your source code, portions + of this Software are embedded into a machine-executable object form of such + source code, you may redistribute such embedded portions in such object form + without including the above copyright and permission notices. + */ + +#ifndef FMT_FORMAT_H_ +#define FMT_FORMAT_H_ + +#include // std::signbit +#include // uint32_t +#include // std::memcpy +#include // std::initializer_list +#include // std::numeric_limits +#include // std::uninitialized_copy +#include // std::runtime_error +#include // std::system_error + +#ifdef __cpp_lib_bit_cast +# include // std::bitcast +#endif + +#include "core.h" + +#ifndef FMT_BEGIN_DETAIL_NAMESPACE +# define FMT_BEGIN_DETAIL_NAMESPACE namespace detail { +# define FMT_END_DETAIL_NAMESPACE } +#endif + +#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) +# define FMT_FALLTHROUGH [[fallthrough]] +#elif defined(__clang__) +# define FMT_FALLTHROUGH [[clang::fallthrough]] +#elif FMT_GCC_VERSION >= 700 && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) +# define FMT_FALLTHROUGH [[gnu::fallthrough]] +#else +# define FMT_FALLTHROUGH +#endif + +#ifndef FMT_DEPRECATED +# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900 +# define FMT_DEPRECATED [[deprecated]] +# else +# if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__) +# define FMT_DEPRECATED __attribute__((deprecated)) +# elif FMT_MSC_VERSION +# define FMT_DEPRECATED __declspec(deprecated) +# else +# define FMT_DEPRECATED /* deprecated */ +# endif +# endif +#endif + +#if FMT_GCC_VERSION || defined(__clang__) +# define FMT_VISIBILITY(value) __attribute__((visibility(value))) +#else +# define FMT_VISIBILITY(value) +#endif + +#ifdef __has_builtin +# define FMT_HAS_BUILTIN(x) __has_builtin(x) +#else +# define FMT_HAS_BUILTIN(x) 0 +#endif + +#if FMT_GCC_VERSION || FMT_CLANG_VERSION +# define FMT_NOINLINE __attribute__((noinline)) +#else +# define FMT_NOINLINE +#endif + +#ifndef FMT_THROW +# if FMT_EXCEPTIONS +# if FMT_MSC_VERSION || defined(__NVCC__) +FMT_BEGIN_NAMESPACE +namespace detail { +template inline void do_throw(const Exception& x) { + // Silence unreachable code warnings in MSVC and NVCC because these + // are nearly impossible to fix in a generic code. + volatile bool b = true; + if (b) throw x; +} +} // namespace detail +FMT_END_NAMESPACE +# define FMT_THROW(x) detail::do_throw(x) +# else +# define FMT_THROW(x) throw x +# endif +# else +# define FMT_THROW(x) \ + ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what()) +# endif +#endif + +#if FMT_EXCEPTIONS +# define FMT_TRY try +# define FMT_CATCH(x) catch (x) +#else +# define FMT_TRY if (true) +# define FMT_CATCH(x) if (false) +#endif + +#ifndef FMT_MAYBE_UNUSED +# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused) +# define FMT_MAYBE_UNUSED [[maybe_unused]] +# else +# define FMT_MAYBE_UNUSED +# endif +#endif + +#ifndef FMT_USE_USER_DEFINED_LITERALS +// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs. +# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \ + FMT_MSC_VERSION >= 1900) && \ + (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480) +# define FMT_USE_USER_DEFINED_LITERALS 1 +# else +# define FMT_USE_USER_DEFINED_LITERALS 0 +# endif +#endif + +// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of +// integer formatter template instantiations to just one by only using the +// largest integer type. This results in a reduction in binary size but will +// cause a decrease in integer formatting performance. +#if !defined(FMT_REDUCE_INT_INSTANTIATIONS) +# define FMT_REDUCE_INT_INSTANTIATIONS 0 +#endif + +// __builtin_clz is broken in clang with Microsoft CodeGen: +// https://github.com/fmtlib/fmt/issues/519. +#if !FMT_MSC_VERSION +# if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION +# define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +# endif +# if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION +# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +# endif +#endif + +// __builtin_ctz is broken in Intel Compiler Classic on Windows: +// https://github.com/fmtlib/fmt/issues/2510. +#ifndef __ICL +# if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \ + defined(__NVCOMPILER) +# define FMT_BUILTIN_CTZ(n) __builtin_ctz(n) +# endif +# if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \ + FMT_ICC_VERSION || defined(__NVCOMPILER) +# define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n) +# endif +#endif + +#if FMT_MSC_VERSION +# include // _BitScanReverse[64], _BitScanForward[64], _umul128 +#endif + +// Some compilers masquerade as both MSVC and GCC-likes or otherwise support +// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the +// MSVC intrinsics if the clz and clzll builtins are not available. +#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \ + !defined(FMT_BUILTIN_CTZLL) +FMT_BEGIN_NAMESPACE +namespace detail { +// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. +# if !defined(__clang__) +# pragma intrinsic(_BitScanForward) +# pragma intrinsic(_BitScanReverse) +# if defined(_WIN64) +# pragma intrinsic(_BitScanForward64) +# pragma intrinsic(_BitScanReverse64) +# endif +# endif + +inline auto clz(uint32_t x) -> int { + unsigned long r = 0; + _BitScanReverse(&r, x); + FMT_ASSERT(x != 0, ""); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. + FMT_MSC_WARNING(suppress : 6102) + return 31 ^ static_cast(r); +} +# define FMT_BUILTIN_CLZ(n) detail::clz(n) + +inline auto clzll(uint64_t x) -> int { + unsigned long r = 0; +# ifdef _WIN64 + _BitScanReverse64(&r, x); +# else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 ^ static_cast(r + 32); + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); +# endif + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return 63 ^ static_cast(r); +} +# define FMT_BUILTIN_CLZLL(n) detail::clzll(n) + +inline auto ctz(uint32_t x) -> int { + unsigned long r = 0; + _BitScanForward(&r, x); + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. + return static_cast(r); +} +# define FMT_BUILTIN_CTZ(n) detail::ctz(n) + +inline auto ctzll(uint64_t x) -> int { + unsigned long r = 0; + FMT_ASSERT(x != 0, ""); + FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. +# ifdef _WIN64 + _BitScanForward64(&r, x); +# else + // Scan the low 32 bits. + if (_BitScanForward(&r, static_cast(x))) return static_cast(r); + // Scan the high 32 bits. + _BitScanForward(&r, static_cast(x >> 32)); + r += 32; +# endif + return static_cast(r); +} +# define FMT_BUILTIN_CTZLL(n) detail::ctzll(n) +} // namespace detail +FMT_END_NAMESPACE +#endif + +FMT_BEGIN_NAMESPACE + +template struct disjunction : std::false_type {}; +template struct disjunction

: P {}; +template +struct disjunction + : conditional_t> {}; + +template struct conjunction : std::true_type {}; +template struct conjunction

: P {}; +template +struct conjunction + : conditional_t, P1> {}; + +namespace detail { + +FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { + ignore_unused(condition); +#ifdef FMT_FUZZ + if (condition) throw std::runtime_error("fuzzing limit reached"); +#endif +} + +template struct string_literal { + static constexpr CharT value[sizeof...(C)] = {C...}; + constexpr operator basic_string_view() const { + return {value, sizeof...(C)}; + } +}; + +#if FMT_CPLUSPLUS < 201703L +template +constexpr CharT string_literal::value[sizeof...(C)]; +#endif + +template class formatbuf : public Streambuf { + private: + using char_type = typename Streambuf::char_type; + using streamsize = decltype(std::declval().sputn(nullptr, 0)); + using int_type = typename Streambuf::int_type; + using traits_type = typename Streambuf::traits_type; + + buffer& buffer_; + + public: + explicit formatbuf(buffer& buf) : buffer_(buf) {} + + protected: + // The put area is always empty. This makes the implementation simpler and has + // the advantage that the streambuf and the buffer are always in sync and + // sputc never writes into uninitialized memory. A disadvantage is that each + // call to sputc always results in a (virtual) call to overflow. There is no + // disadvantage here for sputn since this always results in a call to xsputn. + + auto overflow(int_type ch) -> int_type override { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } + + auto xsputn(const char_type* s, streamsize count) -> streamsize override { + buffer_.append(s, s + count); + return count; + } +}; + +// Implementation of std::bit_cast for pre-C++20. +template +FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To { +#ifdef __cpp_lib_bit_cast + if (is_constant_evaluated()) return std::bit_cast(from); +#endif + auto to = To(); + // The cast suppresses a bogus -Wclass-memaccess on GCC. + std::memcpy(static_cast(&to), &from, sizeof(to)); + return to; +} + +inline auto is_big_endian() -> bool { +#ifdef _WIN32 + return false; +#elif defined(__BIG_ENDIAN__) + return true; +#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) + return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__; +#else + struct bytes { + char data[sizeof(int)]; + }; + return bit_cast(1).data[0] == 0; +#endif +} + +class uint128_fallback { + private: + uint64_t lo_, hi_; + + friend uint128_fallback umul128(uint64_t x, uint64_t y) noexcept; + + public: + constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} + constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} + + constexpr uint64_t high() const noexcept { return hi_; } + constexpr uint64_t low() const noexcept { return lo_; } + + template ::value)> + constexpr explicit operator T() const { + return static_cast(lo_); + } + + friend constexpr auto operator==(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> bool { + return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_; + } + friend constexpr auto operator!=(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> bool { + return !(lhs == rhs); + } + friend constexpr auto operator>(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> bool { + return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_; + } + friend constexpr auto operator|(const uint128_fallback& lhs, + const uint128_fallback& rhs) + -> uint128_fallback { + return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_}; + } + friend constexpr auto operator&(const uint128_fallback& lhs, + const uint128_fallback& rhs) + -> uint128_fallback { + return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_}; + } + friend constexpr auto operator~(const uint128_fallback& n) + -> uint128_fallback { + return {~n.hi_, ~n.lo_}; + } + friend auto operator+(const uint128_fallback& lhs, + const uint128_fallback& rhs) -> uint128_fallback { + auto result = uint128_fallback(lhs); + result += rhs; + return result; + } + friend auto operator*(const uint128_fallback& lhs, uint32_t rhs) + -> uint128_fallback { + FMT_ASSERT(lhs.hi_ == 0, ""); + uint64_t hi = (lhs.lo_ >> 32) * rhs; + uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs; + uint64_t new_lo = (hi << 32) + lo; + return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; + } + friend auto operator-(const uint128_fallback& lhs, uint64_t rhs) + -> uint128_fallback { + return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; + } + FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback { + if (shift == 64) return {0, hi_}; + if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64); + return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)}; + } + FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback { + if (shift == 64) return {lo_, 0}; + if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64); + return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)}; + } + FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& { + return *this = *this >> shift; + } + FMT_CONSTEXPR void operator+=(uint128_fallback n) { + uint64_t new_lo = lo_ + n.lo_; + uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0); + FMT_ASSERT(new_hi >= hi_, ""); + lo_ = new_lo; + hi_ = new_hi; + } + FMT_CONSTEXPR void operator&=(uint128_fallback n) { + lo_ &= n.lo_; + hi_ &= n.hi_; + } + + FMT_CONSTEXPR20 uint128_fallback& operator+=(uint64_t n) noexcept { + if (is_constant_evaluated()) { + lo_ += n; + hi_ += (lo_ < n ? 1 : 0); + return *this; + } +#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__) + unsigned long long carry; + lo_ = __builtin_addcll(lo_, n, 0, &carry); + hi_ += carry; +#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__) + unsigned long long result; + auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result); + lo_ = result; + hi_ += carry; +#elif defined(_MSC_VER) && defined(_M_X64) + auto carry = _addcarry_u64(0, lo_, n, &lo_); + _addcarry_u64(carry, hi_, 0, &hi_); +#else + lo_ += n; + hi_ += (lo_ < n ? 1 : 0); +#endif + return *this; + } +}; + +using uint128_t = conditional_t; + +#ifdef UINTPTR_MAX +using uintptr_t = ::uintptr_t; +#else +using uintptr_t = uint128_t; +#endif + +// Returns the largest possible value for type T. Same as +// std::numeric_limits::max() but shorter and not affected by the max macro. +template constexpr auto max_value() -> T { + return (std::numeric_limits::max)(); +} +template constexpr auto num_bits() -> int { + return std::numeric_limits::digits; +} +// std::numeric_limits::digits may return 0 for 128-bit ints. +template <> constexpr auto num_bits() -> int { return 128; } +template <> constexpr auto num_bits() -> int { return 128; } + +// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t +// and 128-bit pointers to uint128_fallback. +template sizeof(From))> +inline auto bit_cast(const From& from) -> To { + constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned)); + struct data_t { + unsigned value[static_cast(size)]; + } data = bit_cast(from); + auto result = To(); + if (const_check(is_big_endian())) { + for (int i = 0; i < size; ++i) + result = (result << num_bits()) | data.value[i]; + } else { + for (int i = size - 1; i >= 0; --i) + result = (result << num_bits()) | data.value[i]; + } + return result; +} + +template +FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int { + int lz = 0; + constexpr UInt msb_mask = static_cast(1) << (num_bits() - 1); + for (; (n & msb_mask) == 0; n <<= 1) lz++; + return lz; +} + +FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int { +#ifdef FMT_BUILTIN_CLZ + if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n); +#endif + return countl_zero_fallback(n); +} + +FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int { +#ifdef FMT_BUILTIN_CLZLL + if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n); +#endif + return countl_zero_fallback(n); +} + +FMT_INLINE void assume(bool condition) { + (void)condition; +#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION + __builtin_assume(condition); +#endif +} + +// An approximation of iterator_t for pre-C++20 systems. +template +using iterator_t = decltype(std::begin(std::declval())); +template using sentinel_t = decltype(std::end(std::declval())); + +// A workaround for std::string not having mutable data() until C++17. +template +inline auto get_data(std::basic_string& s) -> Char* { + return &s[0]; +} +template +inline auto get_data(Container& c) -> typename Container::value_type* { + return c.data(); +} + +#if defined(_SECURE_SCL) && _SECURE_SCL +// Make a checked iterator to avoid MSVC warnings. +template using checked_ptr = stdext::checked_array_iterator; +template +constexpr auto make_checked(T* p, size_t size) -> checked_ptr { + return {p, size}; +} +#else +template using checked_ptr = T*; +template constexpr auto make_checked(T* p, size_t) -> T* { + return p; +} +#endif + +// Attempts to reserve space for n extra characters in the output range. +// Returns a pointer to the reserved range or a reference to it. +template ::value)> +#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION +__attribute__((no_sanitize("undefined"))) +#endif +inline auto +reserve(std::back_insert_iterator it, size_t n) + -> checked_ptr { + Container& c = get_container(it); + size_t size = c.size(); + c.resize(size + n); + return make_checked(get_data(c) + size, n); +} + +template +inline auto reserve(buffer_appender it, size_t n) -> buffer_appender { + buffer& buf = get_container(it); + buf.try_reserve(buf.size() + n); + return it; +} + +template +constexpr auto reserve(Iterator& it, size_t) -> Iterator& { + return it; +} + +template +using reserve_iterator = + remove_reference_t(), 0))>; + +template +constexpr auto to_pointer(OutputIt, size_t) -> T* { + return nullptr; +} +template auto to_pointer(buffer_appender it, size_t n) -> T* { + buffer& buf = get_container(it); + auto size = buf.size(); + if (buf.capacity() < size + n) return nullptr; + buf.try_resize(size + n); + return buf.data() + size; +} + +template ::value)> +inline auto base_iterator(std::back_insert_iterator& it, + checked_ptr) + -> std::back_insert_iterator { + return it; +} + +template +constexpr auto base_iterator(Iterator, Iterator it) -> Iterator { + return it; +} + +// is spectacularly slow to compile in C++20 so use a simple fill_n +// instead (#1998). +template +FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) + -> OutputIt { + for (Size i = 0; i < count; ++i) *out++ = value; + return out; +} +template +FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { + if (is_constant_evaluated()) { + return fill_n(out, count, value); + } + std::memset(out, value, to_unsigned(count)); + return out + count; +} + +#ifdef __cpp_char8_t +using char8_type = char8_t; +#else +enum char8_type : unsigned char {}; +#endif + +template +FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end, + OutputIt out) -> OutputIt { + return copy_str(begin, end, out); +} + +// A public domain branchless UTF-8 decoder by Christopher Wellons: +// https://github.com/skeeto/branchless-utf8 +/* Decode the next character, c, from s, reporting errors in e. + * + * Since this is a branchless decoder, four bytes will be read from the + * buffer regardless of the actual length of the next character. This + * means the buffer _must_ have at least three bytes of zero padding + * following the end of the data stream. + * + * Errors are reported in e, which will be non-zero if the parsed + * character was somehow invalid: invalid byte sequence, non-canonical + * encoding, or a surrogate half. + * + * The function returns a pointer to the next character. When an error + * occurs, this pointer will be a guess that depends on the particular + * error, but it will always advance at least one byte. + */ +FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e) + -> const char* { + constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; + constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; + constexpr const int shiftc[] = {0, 18, 12, 6, 0}; + constexpr const int shifte[] = {0, 6, 4, 2, 0}; + + int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4" + [static_cast(*s) >> 3]; + // Compute the pointer to the next character early so that the next + // iteration can start working on the next character. Neither Clang + // nor GCC figure out this reordering on their own. + const char* next = s + len + !len; + + using uchar = unsigned char; + + // Assume a four-byte character and load four bytes. Unused bits are + // shifted out. + *c = uint32_t(uchar(s[0]) & masks[len]) << 18; + *c |= uint32_t(uchar(s[1]) & 0x3f) << 12; + *c |= uint32_t(uchar(s[2]) & 0x3f) << 6; + *c |= uint32_t(uchar(s[3]) & 0x3f) << 0; + *c >>= shiftc[len]; + + // Accumulate the various error conditions. + *e = (*c < mins[len]) << 6; // non-canonical encoding + *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half? + *e |= (*c > 0x10FFFF) << 8; // out of range? + *e |= (uchar(s[1]) & 0xc0) >> 2; + *e |= (uchar(s[2]) & 0xc0) >> 4; + *e |= uchar(s[3]) >> 6; + *e ^= 0x2a; // top two bits of each tail byte correct? + *e >>= shifte[len]; + + return next; +} + +constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t(); + +// Invokes f(cp, sv) for every code point cp in s with sv being the string view +// corresponding to the code point. cp is invalid_code_point on error. +template +FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { + auto decode = [f](const char* buf_ptr, const char* ptr) { + auto cp = uint32_t(); + auto error = 0; + auto end = utf8_decode(buf_ptr, &cp, &error); + bool result = f(error ? invalid_code_point : cp, + string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); + return result ? (error ? buf_ptr + 1 : end) : nullptr; + }; + auto p = s.data(); + const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. + if (s.size() >= block_size) { + for (auto end = p + s.size() - block_size + 1; p < end;) { + p = decode(p, p); + if (!p) return; + } + } + if (auto num_chars_left = s.data() + s.size() - p) { + char buf[2 * block_size - 1] = {}; + copy_str(p, p + num_chars_left, buf); + const char* buf_ptr = buf; + do { + auto end = decode(buf_ptr, p); + if (!end) return; + p += end - buf_ptr; + buf_ptr = end; + } while (buf_ptr - buf < num_chars_left); + } +} + +template +inline auto compute_width(basic_string_view s) -> size_t { + return s.size(); +} + +// Computes approximate display width of a UTF-8 string. +FMT_CONSTEXPR inline size_t compute_width(string_view s) { + size_t num_code_points = 0; + // It is not a lambda for compatibility with C++14. + struct count_code_points { + size_t* count; + FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool { + *count += detail::to_unsigned( + 1 + + (cp >= 0x1100 && + (cp <= 0x115f || // Hangul Jamo init. consonants + cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET + cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET + // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE: + (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) || + (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables + (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs + (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms + (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms + (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms + (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms + (cp >= 0x20000 && cp <= 0x2fffd) || // CJK + (cp >= 0x30000 && cp <= 0x3fffd) || + // Miscellaneous Symbols and Pictographs + Emoticons: + (cp >= 0x1f300 && cp <= 0x1f64f) || + // Supplemental Symbols and Pictographs: + (cp >= 0x1f900 && cp <= 0x1f9ff)))); + return true; + } + }; + // We could avoid branches by using utf8_decode directly. + for_each_codepoint(s, count_code_points{&num_code_points}); + return num_code_points; +} + +inline auto compute_width(basic_string_view s) -> size_t { + return compute_width( + string_view(reinterpret_cast(s.data()), s.size())); +} + +template +inline auto code_point_index(basic_string_view s, size_t n) -> size_t { + size_t size = s.size(); + return n < size ? n : size; +} + +// Calculates the index of the nth code point in a UTF-8 string. +inline auto code_point_index(string_view s, size_t n) -> size_t { + const char* data = s.data(); + size_t num_code_points = 0; + for (size_t i = 0, size = s.size(); i != size; ++i) { + if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i; + } + return s.size(); +} + +inline auto code_point_index(basic_string_view s, size_t n) + -> size_t { + return code_point_index( + string_view(reinterpret_cast(s.data()), s.size()), n); +} + +template struct is_integral : std::is_integral {}; +template <> struct is_integral : std::true_type {}; +template <> struct is_integral : std::true_type {}; + +template +using is_signed = + std::integral_constant::is_signed || + std::is_same::value>; + +template +using is_integer = + bool_constant::value && !std::is_same::value && + !std::is_same::value && + !std::is_same::value>; + +#ifndef FMT_USE_FLOAT +# define FMT_USE_FLOAT 1 +#endif +#ifndef FMT_USE_DOUBLE +# define FMT_USE_DOUBLE 1 +#endif +#ifndef FMT_USE_LONG_DOUBLE +# define FMT_USE_LONG_DOUBLE 1 +#endif + +#ifndef FMT_USE_FLOAT128 +# ifdef __clang__ +// Clang emulates GCC, so it has to appear early. +# if FMT_HAS_INCLUDE() +# define FMT_USE_FLOAT128 1 +# endif +# elif defined(__GNUC__) +// GNU C++: +# if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__) +# define FMT_USE_FLOAT128 1 +# endif +# endif +# ifndef FMT_USE_FLOAT128 +# define FMT_USE_FLOAT128 0 +# endif +#endif + +#if FMT_USE_FLOAT128 +using float128 = __float128; +#else +using float128 = void; +#endif +template using is_float128 = std::is_same; + +template +using is_floating_point = + bool_constant::value || is_float128::value>; + +template ::value> +struct is_fast_float : bool_constant::is_iec559 && + sizeof(T) <= sizeof(double)> {}; +template struct is_fast_float : std::false_type {}; + +template +using is_double_double = bool_constant::digits == 106>; + +#ifndef FMT_USE_FULL_CACHE_DRAGONBOX +# define FMT_USE_FULL_CACHE_DRAGONBOX 0 +#endif + +template +template +void buffer::append(const U* begin, const U* end) { + while (begin != end) { + auto count = to_unsigned(end - begin); + try_reserve(size_ + count); + auto free_cap = capacity_ - size_; + if (free_cap < count) count = free_cap; + std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count)); + size_ += count; + begin += count; + } +} + +template +struct is_locale : std::false_type {}; +template +struct is_locale> : std::true_type {}; +} // namespace detail + +FMT_BEGIN_EXPORT + +// The number of characters to store in the basic_memory_buffer object itself +// to avoid dynamic memory allocation. +enum { inline_buffer_size = 500 }; + +/** + \rst + A dynamically growing memory buffer for trivially copyable/constructible types + with the first ``SIZE`` elements stored in the object itself. + + You can use the ``memory_buffer`` type alias for ``char`` instead. + + **Example**:: + + auto out = fmt::memory_buffer(); + format_to(std::back_inserter(out), "The answer is {}.", 42); + + This will append the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42. + + The output can be converted to an ``std::string`` with ``to_string(out)``. + \endrst + */ +template > +class basic_memory_buffer final : public detail::buffer { + private: + T store_[SIZE]; + + // Don't inherit from Allocator avoid generating type_info for it. + Allocator alloc_; + + // Deallocate memory allocated by the buffer. + FMT_CONSTEXPR20 void deallocate() { + T* data = this->data(); + if (data != store_) alloc_.deallocate(data, this->capacity()); + } + + protected: + FMT_CONSTEXPR20 void grow(size_t size) override { + detail::abort_fuzzing_if(size > 5000); + const size_t max_size = std::allocator_traits::max_size(alloc_); + size_t old_capacity = this->capacity(); + size_t new_capacity = old_capacity + old_capacity / 2; + if (size > new_capacity) + new_capacity = size; + else if (new_capacity > max_size) + new_capacity = size > max_size ? size : max_size; + T* old_data = this->data(); + T* new_data = + std::allocator_traits::allocate(alloc_, new_capacity); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_copy(old_data, old_data + this->size(), + detail::make_checked(new_data, new_capacity)); + this->set(new_data, new_capacity); + // deallocate must not throw according to the standard, but even if it does, + // the buffer already uses the new storage and will deallocate it in + // destructor. + if (old_data != store_) alloc_.deallocate(old_data, old_capacity); + } + + public: + using value_type = T; + using const_reference = const T&; + + FMT_CONSTEXPR20 explicit basic_memory_buffer( + const Allocator& alloc = Allocator()) + : alloc_(alloc) { + this->set(store_, SIZE); + if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T()); + } + FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); } + + private: + // Move data from other to this buffer. + FMT_CONSTEXPR20 void move(basic_memory_buffer& other) { + alloc_ = std::move(other.alloc_); + T* data = other.data(); + size_t size = other.size(), capacity = other.capacity(); + if (data == other.store_) { + this->set(store_, capacity); + detail::copy_str(other.store_, other.store_ + size, + detail::make_checked(store_, capacity)); + } else { + this->set(data, capacity); + // Set pointer to the inline array so that delete is not called + // when deallocating. + other.set(other.store_, 0); + other.clear(); + } + this->resize(size); + } + + public: + /** + \rst + Constructs a :class:`fmt::basic_memory_buffer` object moving the content + of the other object to it. + \endrst + */ + FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept { + move(other); + } + + /** + \rst + Moves the content of the other ``basic_memory_buffer`` object to this one. + \endrst + */ + auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { + FMT_ASSERT(this != &other, ""); + deallocate(); + move(other); + return *this; + } + + // Returns a copy of the allocator associated with this buffer. + auto get_allocator() const -> Allocator { return alloc_; } + + /** + Resizes the buffer to contain *count* elements. If T is a POD type new + elements may not be initialized. + */ + FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); } + + /** Increases the buffer capacity to *new_capacity*. */ + void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } + + // Directly append data into the buffer + using detail::buffer::append; + template + void append(const ContiguousRange& range) { + append(range.data(), range.data() + range.size()); + } +}; + +using memory_buffer = basic_memory_buffer; + +template +struct is_contiguous> : std::true_type { +}; + +FMT_END_EXPORT +namespace detail { +FMT_API bool write_console(std::FILE* f, string_view text); +FMT_API void print(std::FILE*, string_view); +} // namespace detail +FMT_BEGIN_EXPORT + +// Suppress a misleading warning in older versions of clang. +#if FMT_CLANG_VERSION +# pragma clang diagnostic ignored "-Wweak-vtables" +#endif + +/** An error reported from a formatting function. */ +class FMT_VISIBILITY("default") format_error : public std::runtime_error { + public: + using std::runtime_error::runtime_error; +}; + +namespace detail_exported { +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +template struct fixed_string { + constexpr fixed_string(const Char (&str)[N]) { + detail::copy_str(static_cast(str), + str + N, data); + } + Char data[N] = {}; +}; +#endif + +// Converts a compile-time string to basic_string_view. +template +constexpr auto compile_string_to_view(const Char (&s)[N]) + -> basic_string_view { + // Remove trailing NUL character if needed. Won't be present if this is used + // with a raw character array (i.e. not defined as a string). + return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; +} +template +constexpr auto compile_string_to_view(detail::std_string_view s) + -> basic_string_view { + return {s.data(), s.size()}; +} +} // namespace detail_exported + +class loc_value { + private: + basic_format_arg value_; + + public: + template ::value)> + loc_value(T value) : value_(detail::make_arg(value)) {} + + template ::value)> + loc_value(T) {} + + template auto visit(Visitor&& vis) -> decltype(vis(0)) { + return visit_format_arg(vis, value_); + } +}; + +// A locale facet that formats values in UTF-8. +// It is parameterized on the locale to avoid the heavy include. +template class format_facet : public Locale::facet { + private: + std::string separator_; + std::string grouping_; + std::string decimal_point_; + + protected: + virtual auto do_put(appender out, loc_value val, + const format_specs<>& specs) const -> bool; + + public: + static FMT_API typename Locale::id id; + + explicit format_facet(Locale& loc); + explicit format_facet(string_view sep = "", + std::initializer_list g = {3}, + std::string decimal_point = ".") + : separator_(sep.data(), sep.size()), + grouping_(g.begin(), g.end()), + decimal_point_(decimal_point) {} + + auto put(appender out, loc_value val, const format_specs<>& specs) const + -> bool { + return do_put(out, val, specs); + } +}; + +FMT_BEGIN_DETAIL_NAMESPACE + +// Returns true if value is negative, false otherwise. +// Same as `value < 0` but doesn't produce warnings if T is an unsigned type. +template ::value)> +constexpr auto is_negative(T value) -> bool { + return value < 0; +} +template ::value)> +constexpr auto is_negative(T) -> bool { + return false; +} + +template +FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool { + if (std::is_same()) return FMT_USE_FLOAT; + if (std::is_same()) return FMT_USE_DOUBLE; + if (std::is_same()) return FMT_USE_LONG_DOUBLE; + return true; +} + +// Smallest of uint32_t, uint64_t, uint128_t that is large enough to +// represent all values of an integral type T. +template +using uint32_or_64_or_128_t = + conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, + uint32_t, + conditional_t() <= 64, uint64_t, uint128_t>>; +template +using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; + +#define FMT_POWERS_OF_10(factor) \ + factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \ + (factor)*1000000, (factor)*10000000, (factor)*100000000, \ + (factor)*1000000000 + +// Converts value in the range [0, 100) to a string. +constexpr const char* digits2(size_t value) { + // GCC generates slightly better code when value is pointer-size. + return &"0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"[value * 2]; +} + +// Sign is a template parameter to workaround a bug in gcc 4.8. +template constexpr Char sign(Sign s) { +#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604 + static_assert(std::is_same::value, ""); +#endif + return static_cast("\0-+ "[s]); +} + +template FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { + int count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } +} +#if FMT_USE_INT128 +FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int { + return count_digits_fallback(n); +} +#endif + +#ifdef FMT_BUILTIN_CLZLL +// It is a separate function rather than a part of count_digits to workaround +// the lack of static constexpr in constexpr functions. +inline auto do_count_digits(uint64_t n) -> int { + // This has comparable performance to the version by Kendall Willets + // (https://github.com/fmtlib/format-benchmark/blob/master/digits10) + // but uses smaller tables. + // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). + static constexpr uint8_t bsr2log10[] = { + 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, + 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, + 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, + 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20}; + auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63]; + static constexpr const uint64_t zero_or_powers_of_10[] = { + 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), + 10000000000000000000ULL}; + return t - (n < zero_or_powers_of_10[t]); +} +#endif + +// Returns the number of decimal digits in n. Leading zeros are not counted +// except for n == 0 in which case count_digits returns 1. +FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { +#ifdef FMT_BUILTIN_CLZLL + if (!is_constant_evaluated()) { + return do_count_digits(n); + } +#endif + return count_digits_fallback(n); +} + +// Counts the number of digits in n. BITS = log2(radix). +template +FMT_CONSTEXPR auto count_digits(UInt n) -> int { +#ifdef FMT_BUILTIN_CLZ + if (!is_constant_evaluated() && num_bits() == 32) + return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; +#endif + // Lambda avoids unreachable code warnings from NVHPC. + return [](UInt m) { + int num_digits = 0; + do { + ++num_digits; + } while ((m >>= BITS) != 0); + return num_digits; + }(n); +} + +#ifdef FMT_BUILTIN_CLZ +// It is a separate function rather than a part of count_digits to workaround +// the lack of static constexpr in constexpr functions. +FMT_INLINE auto do_count_digits(uint32_t n) -> int { +// An optimization by Kendall Willets from https://bit.ly/3uOIQrB. +// This increments the upper 32 bits (log10(T) - 1) when >= T is added. +# define FMT_INC(T) (((sizeof(# T) - 1ull) << 32) - T) + static constexpr uint64_t table[] = { + FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 + FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 + FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512 + FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096 + FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k + FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k + FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k + FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M + FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M + FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M + FMT_INC(1000000000), FMT_INC(1000000000) // 4B + }; + auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31]; + return static_cast((n + inc) >> 32); +} +#endif + +// Optional version of count_digits for better performance on 32-bit platforms. +FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int { +#ifdef FMT_BUILTIN_CLZ + if (!is_constant_evaluated()) { + return do_count_digits(n); + } +#endif + return count_digits_fallback(n); +} + +template constexpr auto digits10() noexcept -> int { + return std::numeric_limits::digits10; +} +template <> constexpr auto digits10() noexcept -> int { return 38; } +template <> constexpr auto digits10() noexcept -> int { return 38; } + +template struct thousands_sep_result { + std::string grouping; + Char thousands_sep; +}; + +template +FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result; +template +inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { + auto result = thousands_sep_impl(loc); + return {result.grouping, Char(result.thousands_sep)}; +} +template <> +inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { + return thousands_sep_impl(loc); +} + +template +FMT_API auto decimal_point_impl(locale_ref loc) -> Char; +template inline auto decimal_point(locale_ref loc) -> Char { + return Char(decimal_point_impl(loc)); +} +template <> inline auto decimal_point(locale_ref loc) -> wchar_t { + return decimal_point_impl(loc); +} + +// Compares two characters for equality. +template auto equal2(const Char* lhs, const char* rhs) -> bool { + return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); +} +inline auto equal2(const char* lhs, const char* rhs) -> bool { + return memcmp(lhs, rhs, 2) == 0; +} + +// Copies two characters from src to dst. +template +FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) { + if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) { + memcpy(dst, src, 2); + return; + } + *dst++ = static_cast(*src++); + *dst = static_cast(*src); +} + +template struct format_decimal_result { + Iterator begin; + Iterator end; +}; + +// Formats a decimal unsigned integer value writing into out pointing to a +// buffer of specified size. The caller must ensure that the buffer is large +// enough. +template +FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size) + -> format_decimal_result { + FMT_ASSERT(size >= count_digits(value), "invalid digit count"); + out += size; + Char* end = out; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + out -= 2; + copy2(out, digits2(static_cast(value % 100))); + value /= 100; + } + if (value < 10) { + *--out = static_cast('0' + value); + return {out, end}; + } + out -= 2; + copy2(out, digits2(static_cast(value))); + return {out, end}; +} + +template >::value)> +FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size) + -> format_decimal_result { + // Buffer is large enough to hold all digits (digits10 + 1). + Char buffer[digits10() + 1] = {}; + auto end = format_decimal(buffer, value, size).end; + return {out, detail::copy_str_noinline(buffer, end, out)}; +} + +template +FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits, + bool upper = false) -> Char* { + buffer += num_digits; + Char* end = buffer; + do { + const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; + unsigned digit = static_cast(value & ((1 << BASE_BITS) - 1)); + *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) + : digits[digit]); + } while ((value >>= BASE_BITS) != 0); + return end; +} + +template +inline auto format_uint(It out, UInt value, int num_digits, bool upper = false) + -> It { + if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { + format_uint(ptr, value, num_digits, upper); + return out; + } + // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1). + char buffer[num_bits() / BASE_BITS + 1]; + format_uint(buffer, value, num_digits, upper); + return detail::copy_str_noinline(buffer, buffer + num_digits, out); +} + +// A converter from UTF-8 to UTF-16. +class utf8_to_utf16 { + private: + basic_memory_buffer buffer_; + + public: + FMT_API explicit utf8_to_utf16(string_view s); + operator basic_string_view() const { return {&buffer_[0], size()}; } + auto size() const -> size_t { return buffer_.size() - 1; } + auto c_str() const -> const wchar_t* { return &buffer_[0]; } + auto str() const -> std::wstring { return {&buffer_[0], size()}; } +}; + +// A converter from UTF-16/UTF-32 (host endian) to UTF-8. +template class to_utf8 { + private: + Buffer buffer_; + + public: + to_utf8() {} + explicit to_utf8(basic_string_view s) { + static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, + "Expect utf16 or utf32"); + + if (!convert(s)) + FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" + : "invalid utf32")); + } + operator string_view() const { return string_view(&buffer_[0], size()); } + size_t size() const { return buffer_.size() - 1; } + const char* c_str() const { return &buffer_[0]; } + std::string str() const { return std::string(&buffer_[0], size()); } + + // Performs conversion returning a bool instead of throwing exception on + // conversion error. This method may still throw in case of memory allocation + // error. + bool convert(basic_string_view s) { + if (!convert(buffer_, s)) return false; + buffer_.push_back(0); + return true; + } + static bool convert(Buffer& buf, basic_string_view s) { + for (auto p = s.begin(); p != s.end(); ++p) { + uint32_t c = static_cast(*p); + if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { + // surrogate pair + ++p; + if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) { + return false; + } + c = (c << 10) + static_cast(*p) - 0x35fdc00; + } + if (c < 0x80) { + buf.push_back(static_cast(c)); + } else if (c < 0x800) { + buf.push_back(static_cast(0xc0 | (c >> 6))); + buf.push_back(static_cast(0x80 | (c & 0x3f))); + } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) { + buf.push_back(static_cast(0xe0 | (c >> 12))); + buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); + buf.push_back(static_cast(0x80 | (c & 0x3f))); + } else if (c >= 0x10000 && c <= 0x10ffff) { + buf.push_back(static_cast(0xf0 | (c >> 18))); + buf.push_back(static_cast(0x80 | ((c & 0x3ffff) >> 12))); + buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); + buf.push_back(static_cast(0x80 | (c & 0x3f))); + } else { + return false; + } + } + return true; + } +}; + +// Computes 128-bit result of multiplication of two 64-bit unsigned integers. +inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept { +#if FMT_USE_INT128 + auto p = static_cast(x) * static_cast(y); + return {static_cast(p >> 64), static_cast(p)}; +#elif defined(_MSC_VER) && defined(_M_X64) + auto result = uint128_fallback(); + result.lo_ = _umul128(x, y, &result.hi_); + return result; +#else + const uint64_t mask = static_cast(max_value()); + + uint64_t a = x >> 32; + uint64_t b = x & mask; + uint64_t c = y >> 32; + uint64_t d = y & mask; + + uint64_t ac = a * c; + uint64_t bc = b * c; + uint64_t ad = a * d; + uint64_t bd = b * d; + + uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask); + + return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), + (intermediate << 32) + (bd & mask)}; +#endif +} + +namespace dragonbox { +// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from +// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. +inline int floor_log10_pow2(int e) noexcept { + FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); + static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); + return (e * 315653) >> 20; +} + +inline int floor_log2_pow10(int e) noexcept { + FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); + return (e * 1741647) >> 19; +} + +// Computes upper 64 bits of multiplication of two 64-bit unsigned integers. +inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept { +#if FMT_USE_INT128 + auto p = static_cast(x) * static_cast(y); + return static_cast(p >> 64); +#elif defined(_MSC_VER) && defined(_M_X64) + return __umulh(x, y); +#else + return umul128(x, y).high(); +#endif +} + +// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a +// 128-bit unsigned integer. +inline uint128_fallback umul192_upper128(uint64_t x, + uint128_fallback y) noexcept { + uint128_fallback r = umul128(x, y.high()); + r += umul128_upper64(x, y.low()); + return r; +} + +FMT_API uint128_fallback get_cached_power(int k) noexcept; + +// Type-specific information that Dragonbox uses. +template struct float_info; + +template <> struct float_info { + using carrier_uint = uint32_t; + static const int exponent_bits = 8; + static const int kappa = 1; + static const int big_divisor = 100; + static const int small_divisor = 10; + static const int min_k = -31; + static const int max_k = 46; + static const int shorter_interval_tie_lower_threshold = -35; + static const int shorter_interval_tie_upper_threshold = -35; +}; + +template <> struct float_info { + using carrier_uint = uint64_t; + static const int exponent_bits = 11; + static const int kappa = 2; + static const int big_divisor = 1000; + static const int small_divisor = 100; + static const int min_k = -292; + static const int max_k = 341; + static const int shorter_interval_tie_lower_threshold = -77; + static const int shorter_interval_tie_upper_threshold = -77; +}; + +// An 80- or 128-bit floating point number. +template +struct float_info::digits == 64 || + std::numeric_limits::digits == 113 || + is_float128::value>> { + using carrier_uint = detail::uint128_t; + static const int exponent_bits = 15; +}; + +// A double-double floating point number. +template +struct float_info::value>> { + using carrier_uint = detail::uint128_t; +}; + +template struct decimal_fp { + using significand_type = typename float_info::carrier_uint; + significand_type significand; + int exponent; +}; + +template FMT_API auto to_decimal(T x) noexcept -> decimal_fp; +} // namespace dragonbox + +// Returns true iff Float has the implicit bit which is not stored. +template constexpr bool has_implicit_bit() { + // An 80-bit FP number has a 64-bit significand an no implicit bit. + return std::numeric_limits::digits != 64; +} + +// Returns the number of significand bits stored in Float. The implicit bit is +// not counted since it is not stored. +template constexpr int num_significand_bits() { + // std::numeric_limits may not support __float128. + return is_float128() ? 112 + : (std::numeric_limits::digits - + (has_implicit_bit() ? 1 : 0)); +} + +template +constexpr auto exponent_mask() -> + typename dragonbox::float_info::carrier_uint { + using float_uint = typename dragonbox::float_info::carrier_uint; + return ((float_uint(1) << dragonbox::float_info::exponent_bits) - 1) + << num_significand_bits(); +} +template constexpr auto exponent_bias() -> int { + // std::numeric_limits may not support __float128. + return is_float128() ? 16383 + : std::numeric_limits::max_exponent - 1; +} + +// Writes the exponent exp in the form "[+-]d{2,3}" to buffer. +template +FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It { + FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); + if (exp < 0) { + *it++ = static_cast('-'); + exp = -exp; + } else { + *it++ = static_cast('+'); + } + if (exp >= 100) { + const char* top = digits2(to_unsigned(exp / 100)); + if (exp >= 1000) *it++ = static_cast(top[0]); + *it++ = static_cast(top[1]); + exp %= 100; + } + const char* d = digits2(to_unsigned(exp)); + *it++ = static_cast(d[0]); + *it++ = static_cast(d[1]); + return it; +} + +// A floating-point number f * pow(2, e) where F is an unsigned type. +template struct basic_fp { + F f; + int e; + + static constexpr const int num_significand_bits = + static_cast(sizeof(F) * num_bits()); + + constexpr basic_fp() : f(0), e(0) {} + constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} + + // Constructs fp from an IEEE754 floating-point number. + template FMT_CONSTEXPR basic_fp(Float n) { assign(n); } + + // Assigns n to this and return true iff predecessor is closer than successor. + template ::value)> + FMT_CONSTEXPR auto assign(Float n) -> bool { + static_assert(std::numeric_limits::digits <= 113, "unsupported FP"); + // Assume Float is in the format [sign][exponent][significand]. + using carrier_uint = typename dragonbox::float_info::carrier_uint; + const auto num_float_significand_bits = + detail::num_significand_bits(); + const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; + const auto significand_mask = implicit_bit - 1; + auto u = bit_cast(n); + f = static_cast(u & significand_mask); + auto biased_e = static_cast((u & exponent_mask()) >> + num_float_significand_bits); + // The predecessor is closer if n is a normalized power of 2 (f == 0) + // other than the smallest normalized number (biased_e > 1). + auto is_predecessor_closer = f == 0 && biased_e > 1; + if (biased_e == 0) + biased_e = 1; // Subnormals use biased exponent 1 (min exponent). + else if (has_implicit_bit()) + f += static_cast(implicit_bit); + e = biased_e - exponent_bias() - num_float_significand_bits; + if (!has_implicit_bit()) ++e; + return is_predecessor_closer; + } + + template ::value)> + FMT_CONSTEXPR auto assign(Float n) -> bool { + static_assert(std::numeric_limits::is_iec559, "unsupported FP"); + return assign(static_cast(n)); + } +}; + +using fp = basic_fp; + +// Normalizes the value converted from double and multiplied by (1 << SHIFT). +template +FMT_CONSTEXPR basic_fp normalize(basic_fp value) { + // Handle subnormals. + const auto implicit_bit = F(1) << num_significand_bits(); + const auto shifted_implicit_bit = implicit_bit << SHIFT; + while ((value.f & shifted_implicit_bit) == 0) { + value.f <<= 1; + --value.e; + } + // Subtract 1 to account for hidden bit. + const auto offset = basic_fp::num_significand_bits - + num_significand_bits() - SHIFT - 1; + value.f <<= offset; + value.e -= offset; + return value; +} + +// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. +FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) { +#if FMT_USE_INT128 + auto product = static_cast<__uint128_t>(lhs) * rhs; + auto f = static_cast(product >> 64); + return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f; +#else + // Multiply 32-bit parts of significands. + uint64_t mask = (1ULL << 32) - 1; + uint64_t a = lhs >> 32, b = lhs & mask; + uint64_t c = rhs >> 32, d = rhs & mask; + uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; + // Compute mid 64-bit of result and round. + uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); + return ac + (ad >> 32) + (bc >> 32) + (mid >> 32); +#endif +} + +FMT_CONSTEXPR inline fp operator*(fp x, fp y) { + return {multiply(x.f, y.f), x.e + y.e + 64}; +} + +template struct basic_data { + // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. + // These are generated by support/compute-powers.py. + static constexpr uint64_t pow10_significands[87] = { + 0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, + 0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, + 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, + 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, + 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, + 0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7, + 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, + 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, + 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, + 0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053, + 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, + 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, + 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, + 0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb, + 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, + 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984, + 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, + 0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, + 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, + 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85, + 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, + 0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25, + 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, + 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a, + 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, + 0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129, + 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, + 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, + 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b, + }; + +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wnarrowing" +#endif + // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding + // to significands above. + static constexpr int16_t pow10_exponents[87] = { + -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, + -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661, + -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, + -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77, + -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, + 242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508, + 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, + 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066}; +#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409 +# pragma GCC diagnostic pop +#endif + + static constexpr uint64_t power_of_10_64[20] = { + 1, FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL), + 10000000000000000000ULL}; + + // For checking rounding thresholds. + // The kth entry is chosen to be the smallest integer such that the + // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. + static constexpr uint32_t fractional_part_rounding_thresholds[8] = { + 2576980378, // ceil(2^31 + 2^32/10^1) + 2190433321, // ceil(2^31 + 2^32/10^2) + 2151778616, // ceil(2^31 + 2^32/10^3) + 2147913145, // ceil(2^31 + 2^32/10^4) + 2147526598, // ceil(2^31 + 2^32/10^5) + 2147487943, // ceil(2^31 + 2^32/10^6) + 2147484078, // ceil(2^31 + 2^32/10^7) + 2147483691 // ceil(2^31 + 2^32/10^8) + }; +}; + +#if FMT_CPLUSPLUS < 201703L +template constexpr uint64_t basic_data::pow10_significands[]; +template constexpr int16_t basic_data::pow10_exponents[]; +template constexpr uint64_t basic_data::power_of_10_64[]; +template +constexpr uint32_t basic_data::fractional_part_rounding_thresholds[]; +#endif + +// This is a struct rather than an alias to avoid shadowing warnings in gcc. +struct data : basic_data<> {}; + +// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its +// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`. +FMT_CONSTEXPR inline fp get_cached_power(int min_exponent, + int& pow10_exponent) { + const int shift = 32; + // log10(2) = 0x0.4d104d427de7fbcc... + const int64_t significand = 0x4d104d427de7fbcc; + int index = static_cast( + ((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) + + ((int64_t(1) << shift) - 1)) // ceil + >> 32 // arithmetic shift + ); + // Decimal exponent of the first (smallest) cached power of 10. + const int first_dec_exp = -348; + // Difference between 2 consecutive decimal exponents in cached powers of 10. + const int dec_exp_step = 8; + index = (index - first_dec_exp - 1) / dec_exp_step + 1; + pow10_exponent = first_dec_exp + index * dec_exp_step; + // Using *(x + index) instead of x[index] avoids an issue with some compilers + // using the EDG frontend (e.g. nvhpc/22.3 in C++17 mode). + return {*(data::pow10_significands + index), + *(data::pow10_exponents + index)}; +} + +template +using convert_float_result = + conditional_t::value || + std::numeric_limits::digits == + std::numeric_limits::digits, + double, T>; + +template +constexpr auto convert_float(T value) -> convert_float_result { + return static_cast>(value); +} + +template +FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n, + const fill_t& fill) -> OutputIt { + auto fill_size = fill.size(); + if (fill_size == 1) return detail::fill_n(it, n, fill[0]); + auto data = fill.data(); + for (size_t i = 0; i < n; ++i) + it = copy_str(data, data + fill_size, it); + return it; +} + +// Writes the output of f, padded according to format specifications in specs. +// size: output size in code units. +// width: output display width in (terminal) column positions. +template +FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, + size_t size, size_t width, F&& f) -> OutputIt { + static_assert(align == align::left || align == align::right, ""); + unsigned spec_width = to_unsigned(specs.width); + size_t padding = spec_width > width ? spec_width - width : 0; + // Shifts are encoded as string literals because static constexpr is not + // supported in constexpr functions. + auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; + size_t left_padding = padding >> shifts[specs.align]; + size_t right_padding = padding - left_padding; + auto it = reserve(out, size + padding * specs.fill.size()); + if (left_padding != 0) it = fill(it, left_padding, specs.fill); + it = f(it); + if (right_padding != 0) it = fill(it, right_padding, specs.fill); + return base_iterator(out, it); +} + +template +constexpr auto write_padded(OutputIt out, const format_specs& specs, + size_t size, F&& f) -> OutputIt { + return write_padded(out, specs, size, size, f); +} + +template +FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, + const format_specs& specs) -> OutputIt { + return write_padded( + out, specs, bytes.size(), [bytes](reserve_iterator it) { + const char* data = bytes.data(); + return copy_str(data, data + bytes.size(), it); + }); +} + +template +auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) + -> OutputIt { + int num_digits = count_digits<4>(value); + auto size = to_unsigned(num_digits) + size_t(2); + auto write = [=](reserve_iterator it) { + *it++ = static_cast('0'); + *it++ = static_cast('x'); + return format_uint<4, Char>(it, value, num_digits); + }; + return specs ? write_padded(out, *specs, size, write) + : base_iterator(out, write(reserve(out, size))); +} + +// Returns true iff the code point cp is printable. +FMT_API auto is_printable(uint32_t cp) -> bool; + +inline auto needs_escape(uint32_t cp) -> bool { + return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' || + !is_printable(cp); +} + +template struct find_escape_result { + const Char* begin; + const Char* end; + uint32_t cp; +}; + +template +using make_unsigned_char = + typename conditional_t::value, + std::make_unsigned, + type_identity>::type; + +template +auto find_escape(const Char* begin, const Char* end) + -> find_escape_result { + for (; begin != end; ++begin) { + uint32_t cp = static_cast>(*begin); + if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; + if (needs_escape(cp)) return {begin, begin + 1, cp}; + } + return {begin, nullptr, 0}; +} + +inline auto find_escape(const char* begin, const char* end) + -> find_escape_result { + if (!is_utf8()) return find_escape(begin, end); + auto result = find_escape_result{end, nullptr, 0}; + for_each_codepoint(string_view(begin, to_unsigned(end - begin)), + [&](uint32_t cp, string_view sv) { + if (needs_escape(cp)) { + result = {sv.begin(), sv.end(), cp}; + return false; + } + return true; + }); + return result; +} + +#define FMT_STRING_IMPL(s, base, explicit) \ + [] { \ + /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ + /* Use a macro-like name to avoid shadowing warnings. */ \ + struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ + using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t; \ + FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit \ + operator fmt::basic_string_view() const { \ + return fmt::detail_exported::compile_string_to_view(s); \ + } \ + }; \ + return FMT_COMPILE_STRING(); \ + }() + +/** + \rst + Constructs a compile-time format string from a string literal *s*. + + **Example**:: + + // A compile-time error because 'd' is an invalid specifier for strings. + std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); + \endrst + */ +#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, ) + +template +auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { + *out++ = static_cast('\\'); + *out++ = static_cast(prefix); + Char buf[width]; + fill_n(buf, width, static_cast('0')); + format_uint<4>(buf, cp, width); + return copy_str(buf, buf + width, out); +} + +template +auto write_escaped_cp(OutputIt out, const find_escape_result& escape) + -> OutputIt { + auto c = static_cast(escape.cp); + switch (escape.cp) { + case '\n': + *out++ = static_cast('\\'); + c = static_cast('n'); + break; + case '\r': + *out++ = static_cast('\\'); + c = static_cast('r'); + break; + case '\t': + *out++ = static_cast('\\'); + c = static_cast('t'); + break; + case '"': + FMT_FALLTHROUGH; + case '\'': + FMT_FALLTHROUGH; + case '\\': + *out++ = static_cast('\\'); + break; + default: + if (escape.cp < 0x100) { + return write_codepoint<2, Char>(out, 'x', escape.cp); + } + if (escape.cp < 0x10000) { + return write_codepoint<4, Char>(out, 'u', escape.cp); + } + if (escape.cp < 0x110000) { + return write_codepoint<8, Char>(out, 'U', escape.cp); + } + for (Char escape_char : basic_string_view( + escape.begin, to_unsigned(escape.end - escape.begin))) { + out = write_codepoint<2, Char>(out, 'x', + static_cast(escape_char) & 0xFF); + } + return out; + } + *out++ = c; + return out; +} + +template +auto write_escaped_string(OutputIt out, basic_string_view str) + -> OutputIt { + *out++ = static_cast('"'); + auto begin = str.begin(), end = str.end(); + do { + auto escape = find_escape(begin, end); + out = copy_str(begin, escape.begin, out); + begin = escape.end; + if (!begin) break; + out = write_escaped_cp(out, escape); + } while (begin != end); + *out++ = static_cast('"'); + return out; +} + +template +auto write_escaped_char(OutputIt out, Char v) -> OutputIt { + *out++ = static_cast('\''); + if ((needs_escape(static_cast(v)) && v != static_cast('"')) || + v == static_cast('\'')) { + out = write_escaped_cp( + out, find_escape_result{&v, &v + 1, static_cast(v)}); + } else { + *out++ = v; + } + *out++ = static_cast('\''); + return out; +} + +template +FMT_CONSTEXPR auto write_char(OutputIt out, Char value, + const format_specs& specs) -> OutputIt { + bool is_debug = specs.type == presentation_type::debug; + return write_padded(out, specs, 1, [=](reserve_iterator it) { + if (is_debug) return write_escaped_char(it, value); + *it++ = value; + return it; + }); +} +template +FMT_CONSTEXPR auto write(OutputIt out, Char value, + const format_specs& specs, locale_ref loc = {}) + -> OutputIt { + // char is formatted as unsigned char for consistency across platforms. + using unsigned_type = + conditional_t::value, unsigned char, unsigned>; + return check_char_specs(specs) + ? write_char(out, value, specs) + : write(out, static_cast(value), specs, loc); +} + +// Data for write_int that doesn't depend on output iterator type. It is used to +// avoid template code bloat. +template struct write_int_data { + size_t size; + size_t padding; + + FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix, + const format_specs& specs) + : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { + if (specs.align == align::numeric) { + auto width = to_unsigned(specs.width); + if (width > size) { + padding = width - size; + size = width; + } + } else if (specs.precision > num_digits) { + size = (prefix >> 24) + to_unsigned(specs.precision); + padding = to_unsigned(specs.precision - num_digits); + } + } +}; + +// Writes an integer in the format +// +// where are written by write_digits(it). +// prefix contains chars in three lower bytes and the size in the fourth byte. +template +FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits, + unsigned prefix, + const format_specs& specs, + W write_digits) -> OutputIt { + // Slightly faster check for specs.width == 0 && specs.precision == -1. + if ((specs.width | (specs.precision + 1)) == 0) { + auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); + if (prefix != 0) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + } + return base_iterator(out, write_digits(it)); + } + auto data = write_int_data(num_digits, prefix, specs); + return write_padded( + out, specs, data.size, [=](reserve_iterator it) { + for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) + *it++ = static_cast(p & 0xff); + it = detail::fill_n(it, data.padding, static_cast('0')); + return write_digits(it); + }); +} + +template class digit_grouping { + private: + std::string grouping_; + std::basic_string thousands_sep_; + + struct next_state { + std::string::const_iterator group; + int pos; + }; + next_state initial_state() const { return {grouping_.begin(), 0}; } + + // Returns the next digit group separator position. + int next(next_state& state) const { + if (thousands_sep_.empty()) return max_value(); + if (state.group == grouping_.end()) return state.pos += grouping_.back(); + if (*state.group <= 0 || *state.group == max_value()) + return max_value(); + state.pos += *state.group++; + return state.pos; + } + + public: + explicit digit_grouping(locale_ref loc, bool localized = true) { + if (!localized) return; + auto sep = thousands_sep(loc); + grouping_ = sep.grouping; + if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep); + } + digit_grouping(std::string grouping, std::basic_string sep) + : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} + + bool has_separator() const { return !thousands_sep_.empty(); } + + int count_separators(int num_digits) const { + int count = 0; + auto state = initial_state(); + while (num_digits > next(state)) ++count; + return count; + } + + // Applies grouping to digits and write the output to out. + template + Out apply(Out out, basic_string_view digits) const { + auto num_digits = static_cast(digits.size()); + auto separators = basic_memory_buffer(); + separators.push_back(0); + auto state = initial_state(); + while (int i = next(state)) { + if (i >= num_digits) break; + separators.push_back(i); + } + for (int i = 0, sep_index = static_cast(separators.size() - 1); + i < num_digits; ++i) { + if (num_digits - i == separators[sep_index]) { + out = + copy_str(thousands_sep_.data(), + thousands_sep_.data() + thousands_sep_.size(), out); + --sep_index; + } + *out++ = static_cast(digits[to_unsigned(i)]); + } + return out; + } +}; + +// Writes a decimal integer with digit grouping. +template +auto write_int(OutputIt out, UInt value, unsigned prefix, + const format_specs& specs, + const digit_grouping& grouping) -> OutputIt { + static_assert(std::is_same, UInt>::value, ""); + int num_digits = count_digits(value); + char digits[40]; + format_decimal(digits, value, num_digits); + unsigned size = to_unsigned((prefix != 0 ? 1 : 0) + num_digits + + grouping.count_separators(num_digits)); + return write_padded( + out, specs, size, size, [&](reserve_iterator it) { + if (prefix != 0) { + char sign = static_cast(prefix); + *it++ = static_cast(sign); + } + return grouping.apply(it, string_view(digits, to_unsigned(num_digits))); + }); +} + +// Writes a localized value. +FMT_API auto write_loc(appender out, loc_value value, + const format_specs<>& specs, locale_ref loc) -> bool; +template +inline auto write_loc(OutputIt, loc_value, const format_specs&, + locale_ref) -> bool { + return false; +} + +FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { + prefix |= prefix != 0 ? value << 8 : value; + prefix += (1u + (value > 0xff ? 1 : 0)) << 24; +} + +template struct write_int_arg { + UInt abs_value; + unsigned prefix; +}; + +template +FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign) + -> write_int_arg> { + auto prefix = 0u; + auto abs_value = static_cast>(value); + if (is_negative(value)) { + prefix = 0x01000000 | '-'; + abs_value = 0 - abs_value; + } else { + constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+', + 0x1000000u | ' '}; + prefix = prefixes[sign]; + } + return {abs_value, prefix}; +} + +template struct loc_writer { + buffer_appender out; + const format_specs& specs; + std::basic_string sep; + std::string grouping; + std::basic_string decimal_point; + + template ::value)> + auto operator()(T value) -> bool { + auto arg = make_write_int_arg(value, specs.sign); + write_int(out, static_cast>(arg.abs_value), arg.prefix, + specs, digit_grouping(grouping, sep)); + return true; + } + + template ::value)> + auto operator()(T) -> bool { + return false; + } +}; + +template +FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg, + const format_specs& specs, + locale_ref) -> OutputIt { + static_assert(std::is_same>::value, ""); + auto abs_value = arg.abs_value; + auto prefix = arg.prefix; + switch (specs.type) { + case presentation_type::none: + case presentation_type::dec: { + auto num_digits = count_digits(abs_value); + return write_int( + out, num_digits, prefix, specs, [=](reserve_iterator it) { + return format_decimal(it, abs_value, num_digits).end; + }); + } + case presentation_type::hex_lower: + case presentation_type::hex_upper: { + bool upper = specs.type == presentation_type::hex_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0'); + int num_digits = count_digits<4>(abs_value); + return write_int( + out, num_digits, prefix, specs, [=](reserve_iterator it) { + return format_uint<4, Char>(it, abs_value, num_digits, upper); + }); + } + case presentation_type::bin_lower: + case presentation_type::bin_upper: { + bool upper = specs.type == presentation_type::bin_upper; + if (specs.alt) + prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0'); + int num_digits = count_digits<1>(abs_value); + return write_int(out, num_digits, prefix, specs, + [=](reserve_iterator it) { + return format_uint<1, Char>(it, abs_value, num_digits); + }); + } + case presentation_type::oct: { + int num_digits = count_digits<3>(abs_value); + // Octal prefix '0' is counted as a digit, so only add it if precision + // is not greater than the number of digits. + if (specs.alt && specs.precision <= num_digits && abs_value != 0) + prefix_append(prefix, '0'); + return write_int(out, num_digits, prefix, specs, + [=](reserve_iterator it) { + return format_uint<3, Char>(it, abs_value, num_digits); + }); + } + case presentation_type::chr: + return write_char(out, static_cast(abs_value), specs); + default: + throw_format_error("invalid format specifier"); + } + return out; +} +template +FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline( + OutputIt out, write_int_arg arg, const format_specs& specs, + locale_ref loc) -> OutputIt { + return write_int(out, arg, specs, loc); +} +template ::value && + !std::is_same::value && + std::is_same>::value)> +FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, + const format_specs& specs, + locale_ref loc) -> OutputIt { + if (specs.localized && write_loc(out, value, specs, loc)) return out; + return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs, + loc); +} +// An inlined version of write used in format string compilation. +template ::value && + !std::is_same::value && + !std::is_same>::value)> +FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, + const format_specs& specs, + locale_ref loc) -> OutputIt { + if (specs.localized && write_loc(out, value, specs, loc)) return out; + return write_int(out, make_write_int_arg(value, specs.sign), specs, loc); +} + +// An output iterator that counts the number of objects written to it and +// discards them. +class counting_iterator { + private: + size_t count_; + + public: + using iterator_category = std::output_iterator_tag; + using difference_type = std::ptrdiff_t; + using pointer = void; + using reference = void; + FMT_UNCHECKED_ITERATOR(counting_iterator); + + struct value_type { + template FMT_CONSTEXPR void operator=(const T&) {} + }; + + FMT_CONSTEXPR counting_iterator() : count_(0) {} + + FMT_CONSTEXPR size_t count() const { return count_; } + + FMT_CONSTEXPR counting_iterator& operator++() { + ++count_; + return *this; + } + FMT_CONSTEXPR counting_iterator operator++(int) { + auto it = *this; + ++*this; + return it; + } + + FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it, + difference_type n) { + it.count_ += static_cast(n); + return it; + } + + FMT_CONSTEXPR value_type operator*() const { return {}; } +}; + +template +FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, + const format_specs& specs) -> OutputIt { + auto data = s.data(); + auto size = s.size(); + if (specs.precision >= 0 && to_unsigned(specs.precision) < size) + size = code_point_index(s, to_unsigned(specs.precision)); + bool is_debug = specs.type == presentation_type::debug; + size_t width = 0; + if (specs.width != 0) { + if (is_debug) + width = write_escaped_string(counting_iterator{}, s).count(); + else + width = compute_width(basic_string_view(data, size)); + } + return write_padded(out, specs, size, width, + [=](reserve_iterator it) { + if (is_debug) return write_escaped_string(it, s); + return copy_str(data, data + size, it); + }); +} +template +FMT_CONSTEXPR auto write(OutputIt out, + basic_string_view> s, + const format_specs& specs, locale_ref) + -> OutputIt { + return write(out, s, specs); +} +template +FMT_CONSTEXPR auto write(OutputIt out, const Char* s, + const format_specs& specs, locale_ref) + -> OutputIt { + return specs.type != presentation_type::pointer + ? write(out, basic_string_view(s), specs, {}) + : write_ptr(out, bit_cast(s), &specs); +} + +template ::value && + !std::is_same::value && + !std::is_same::value)> +FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { + auto abs_value = static_cast>(value); + bool negative = is_negative(value); + // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. + if (negative) abs_value = ~abs_value + 1; + int num_digits = count_digits(abs_value); + auto size = (negative ? 1 : 0) + static_cast(num_digits); + auto it = reserve(out, size); + if (auto ptr = to_pointer(it, size)) { + if (negative) *ptr++ = static_cast('-'); + format_decimal(ptr, abs_value, num_digits); + return out; + } + if (negative) *it++ = static_cast('-'); + it = format_decimal(it, abs_value, num_digits).end; + return base_iterator(out, it); +} + +// A floating-point presentation format. +enum class float_format : unsigned char { + general, // General: exponent notation or fixed point based on magnitude. + exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3. + fixed, // Fixed point with the default precision of 6, e.g. 0.0012. + hex +}; + +struct float_specs { + int precision; + float_format format : 8; + sign_t sign : 8; + bool upper : 1; + bool locale : 1; + bool binary32 : 1; + bool showpoint : 1; +}; + +template +FMT_CONSTEXPR auto parse_float_type_spec(const format_specs& specs, + ErrorHandler&& eh = {}) + -> float_specs { + auto result = float_specs(); + result.showpoint = specs.alt; + result.locale = specs.localized; + switch (specs.type) { + case presentation_type::none: + result.format = float_format::general; + break; + case presentation_type::general_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::general_lower: + result.format = float_format::general; + break; + case presentation_type::exp_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::exp_lower: + result.format = float_format::exp; + result.showpoint |= specs.precision != 0; + break; + case presentation_type::fixed_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::fixed_lower: + result.format = float_format::fixed; + result.showpoint |= specs.precision != 0; + break; + case presentation_type::hexfloat_upper: + result.upper = true; + FMT_FALLTHROUGH; + case presentation_type::hexfloat_lower: + result.format = float_format::hex; + break; + default: + eh.on_error("invalid format specifier"); + break; + } + return result; +} + +template +FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, + format_specs specs, + const float_specs& fspecs) -> OutputIt { + auto str = + isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf"); + constexpr size_t str_size = 3; + auto sign = fspecs.sign; + auto size = str_size + (sign ? 1 : 0); + // Replace '0'-padding with space for non-finite values. + const bool is_zero_fill = + specs.fill.size() == 1 && *specs.fill.data() == static_cast('0'); + if (is_zero_fill) specs.fill[0] = static_cast(' '); + return write_padded(out, specs, size, [=](reserve_iterator it) { + if (sign) *it++ = detail::sign(sign); + return copy_str(str, str + str_size, it); + }); +} + +// A decimal floating-point number significand * pow(10, exp). +struct big_decimal_fp { + const char* significand; + int significand_size; + int exponent; +}; + +constexpr auto get_significand_size(const big_decimal_fp& f) -> int { + return f.significand_size; +} +template +inline auto get_significand_size(const dragonbox::decimal_fp& f) -> int { + return count_digits(f.significand); +} + +template +constexpr auto write_significand(OutputIt out, const char* significand, + int significand_size) -> OutputIt { + return copy_str(significand, significand + significand_size, out); +} +template +inline auto write_significand(OutputIt out, UInt significand, + int significand_size) -> OutputIt { + return format_decimal(out, significand, significand_size).end; +} +template +FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, + int significand_size, int exponent, + const Grouping& grouping) -> OutputIt { + if (!grouping.has_separator()) { + out = write_significand(out, significand, significand_size); + return detail::fill_n(out, exponent, static_cast('0')); + } + auto buffer = memory_buffer(); + write_significand(appender(buffer), significand, significand_size); + detail::fill_n(appender(buffer), exponent, '0'); + return grouping.apply(out, string_view(buffer.data(), buffer.size())); +} + +template ::value)> +inline auto write_significand(Char* out, UInt significand, int significand_size, + int integral_size, Char decimal_point) -> Char* { + if (!decimal_point) + return format_decimal(out, significand, significand_size).end; + out += significand_size + 1; + Char* end = out; + int floating_size = significand_size - integral_size; + for (int i = floating_size / 2; i > 0; --i) { + out -= 2; + copy2(out, digits2(static_cast(significand % 100))); + significand /= 100; + } + if (floating_size % 2 != 0) { + *--out = static_cast('0' + significand % 10); + significand /= 10; + } + *--out = decimal_point; + format_decimal(out - integral_size, significand, integral_size); + return end; +} + +template >::value)> +inline auto write_significand(OutputIt out, UInt significand, + int significand_size, int integral_size, + Char decimal_point) -> OutputIt { + // Buffer is large enough to hold digits (digits10 + 1) and a decimal point. + Char buffer[digits10() + 2]; + auto end = write_significand(buffer, significand, significand_size, + integral_size, decimal_point); + return detail::copy_str_noinline(buffer, end, out); +} + +template +FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, + int significand_size, int integral_size, + Char decimal_point) -> OutputIt { + out = detail::copy_str_noinline(significand, + significand + integral_size, out); + if (!decimal_point) return out; + *out++ = decimal_point; + return detail::copy_str_noinline(significand + integral_size, + significand + significand_size, out); +} + +template +FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, + int significand_size, int integral_size, + Char decimal_point, + const Grouping& grouping) -> OutputIt { + if (!grouping.has_separator()) { + return write_significand(out, significand, significand_size, integral_size, + decimal_point); + } + auto buffer = basic_memory_buffer(); + write_significand(buffer_appender(buffer), significand, + significand_size, integral_size, decimal_point); + grouping.apply( + out, basic_string_view(buffer.data(), to_unsigned(integral_size))); + return detail::copy_str_noinline(buffer.data() + integral_size, + buffer.end(), out); +} + +template > +FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, + const format_specs& specs, + float_specs fspecs, locale_ref loc) + -> OutputIt { + auto significand = f.significand; + int significand_size = get_significand_size(f); + const Char zero = static_cast('0'); + auto sign = fspecs.sign; + size_t size = to_unsigned(significand_size) + (sign ? 1 : 0); + using iterator = reserve_iterator; + + Char decimal_point = + fspecs.locale ? detail::decimal_point(loc) : static_cast('.'); + + int output_exp = f.exponent + significand_size - 1; + auto use_exp_format = [=]() { + if (fspecs.format == float_format::exp) return true; + if (fspecs.format != float_format::general) return false; + // Use the fixed notation if the exponent is in [exp_lower, exp_upper), + // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. + const int exp_lower = -4, exp_upper = 16; + return output_exp < exp_lower || + output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper); + }; + if (use_exp_format()) { + int num_zeros = 0; + if (fspecs.showpoint) { + num_zeros = fspecs.precision - significand_size; + if (num_zeros < 0) num_zeros = 0; + size += to_unsigned(num_zeros); + } else if (significand_size == 1) { + decimal_point = Char(); + } + auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp; + int exp_digits = 2; + if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3; + + size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits); + char exp_char = fspecs.upper ? 'E' : 'e'; + auto write = [=](iterator it) { + if (sign) *it++ = detail::sign(sign); + // Insert a decimal point after the first digit and add an exponent. + it = write_significand(it, significand, significand_size, 1, + decimal_point); + if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero); + *it++ = static_cast(exp_char); + return write_exponent(output_exp, it); + }; + return specs.width > 0 ? write_padded(out, specs, size, write) + : base_iterator(out, write(reserve(out, size))); + } + + int exp = f.exponent + significand_size; + if (f.exponent >= 0) { + // 1234e5 -> 123400000[.0+] + size += to_unsigned(f.exponent); + int num_zeros = fspecs.precision - exp; + abort_fuzzing_if(num_zeros > 5000); + if (fspecs.showpoint) { + ++size; + if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0; + if (num_zeros > 0) size += to_unsigned(num_zeros); + } + auto grouping = Grouping(loc, fspecs.locale); + size += to_unsigned(grouping.count_separators(exp)); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); + it = write_significand(it, significand, significand_size, + f.exponent, grouping); + if (!fspecs.showpoint) return it; + *it++ = decimal_point; + return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; + }); + } else if (exp > 0) { + // 1234e-2 -> 12.34[0+] + int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0; + size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0); + auto grouping = Grouping(loc, fspecs.locale); + size += to_unsigned(grouping.count_separators(exp)); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); + it = write_significand(it, significand, significand_size, exp, + decimal_point, grouping); + return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it; + }); + } + // 1234e-6 -> 0.001234 + int num_zeros = -exp; + if (significand_size == 0 && fspecs.precision >= 0 && + fspecs.precision < num_zeros) { + num_zeros = fspecs.precision; + } + bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint; + size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros); + return write_padded(out, specs, size, [&](iterator it) { + if (sign) *it++ = detail::sign(sign); + *it++ = zero; + if (!pointy) return it; + *it++ = decimal_point; + it = detail::fill_n(it, num_zeros, zero); + return write_significand(it, significand, significand_size); + }); +} + +template class fallback_digit_grouping { + public: + constexpr fallback_digit_grouping(locale_ref, bool) {} + + constexpr bool has_separator() const { return false; } + + constexpr int count_separators(int) const { return 0; } + + template + constexpr Out apply(Out out, basic_string_view) const { + return out; + } +}; + +template +FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, + const format_specs& specs, + float_specs fspecs, locale_ref loc) + -> OutputIt { + if (is_constant_evaluated()) { + return do_write_float>(out, f, specs, fspecs, + loc); + } else { + return do_write_float(out, f, specs, fspecs, loc); + } +} + +template constexpr bool isnan(T value) { + return !(value >= value); // std::isnan doesn't support __float128. +} + +template +struct has_isfinite : std::false_type {}; + +template +struct has_isfinite> + : std::true_type {}; + +template ::value&& + has_isfinite::value)> +FMT_CONSTEXPR20 bool isfinite(T value) { + constexpr T inf = T(std::numeric_limits::infinity()); + if (is_constant_evaluated()) + return !detail::isnan(value) && value < inf && value > -inf; + return std::isfinite(value); +} +template ::value)> +FMT_CONSTEXPR bool isfinite(T value) { + T inf = T(std::numeric_limits::infinity()); + // std::isfinite doesn't support __float128. + return !detail::isnan(value) && value < inf && value > -inf; +} + +template ::value)> +FMT_INLINE FMT_CONSTEXPR bool signbit(T value) { + if (is_constant_evaluated()) { +#ifdef __cpp_if_constexpr + if constexpr (std::numeric_limits::is_iec559) { + auto bits = detail::bit_cast(static_cast(value)); + return (bits >> (num_bits() - 1)) != 0; + } +#endif + } + return std::signbit(static_cast(value)); +} + +enum class round_direction { unknown, up, down }; + +// Given the divisor (normally a power of 10), the remainder = v % divisor for +// some number v and the error, returns whether v should be rounded up, down, or +// whether the rounding direction can't be determined due to error. +// error should be less than divisor / 2. +FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor, + uint64_t remainder, + uint64_t error) { + FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow. + FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow. + FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow. + // Round down if (remainder + error) * 2 <= divisor. + if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2) + return round_direction::down; + // Round up if (remainder - error) * 2 >= divisor. + if (remainder >= error && + remainder - error >= divisor - (remainder - error)) { + return round_direction::up; + } + return round_direction::unknown; +} + +namespace digits { +enum result { + more, // Generate more digits. + done, // Done generating digits. + error // Digit generation cancelled due to an error. +}; +} + +struct gen_digits_handler { + char* buf; + int size; + int precision; + int exp10; + bool fixed; + + FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor, + uint64_t remainder, uint64_t error, + bool integral) { + FMT_ASSERT(remainder < divisor, ""); + buf[size++] = digit; + if (!integral && error >= remainder) return digits::error; + if (size < precision) return digits::more; + if (!integral) { + // Check if error * 2 < divisor with overflow prevention. + // The check is not needed for the integral part because error = 1 + // and divisor > (1 << 32) there. + if (error >= divisor || error >= divisor - error) return digits::error; + } else { + FMT_ASSERT(error == 1 && divisor > 2, ""); + } + auto dir = get_round_direction(divisor, remainder, error); + if (dir != round_direction::up) + return dir == round_direction::down ? digits::done : digits::error; + ++buf[size - 1]; + for (int i = size - 1; i > 0 && buf[i] > '9'; --i) { + buf[i] = '0'; + ++buf[i - 1]; + } + if (buf[0] > '9') { + buf[0] = '1'; + if (fixed) + buf[size++] = '0'; + else + ++exp10; + } + return digits::done; + } +}; + +inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { + // Adjust fixed precision by exponent because it is relative to decimal + // point. + if (exp10 > 0 && precision > max_value() - exp10) + FMT_THROW(format_error("number is too big")); + precision += exp10; +} + +// Generates output using the Grisu digit-gen algorithm. +// error: the size of the region (lower, upper) outside of which numbers +// definitely do not round to value (Delta in Grisu3). +FMT_INLINE FMT_CONSTEXPR20 auto grisu_gen_digits(fp value, uint64_t error, + int& exp, + gen_digits_handler& handler) + -> digits::result { + const fp one(1ULL << -value.e, value.e); + // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be + // zero because it contains a product of two 64-bit numbers with MSB set (due + // to normalization) - 1, shifted right by at most 60 bits. + auto integral = static_cast(value.f >> -one.e); + FMT_ASSERT(integral != 0, ""); + FMT_ASSERT(integral == value.f >> -one.e, ""); + // The fractional part of scaled value (p2 in Grisu) c = value % one. + uint64_t fractional = value.f & (one.f - 1); + exp = count_digits(integral); // kappa in Grisu. + // Non-fixed formats require at least one digit and no precision adjustment. + if (handler.fixed) { + adjust_precision(handler.precision, exp + handler.exp10); + // Check if precision is satisfied just by leading zeros, e.g. + // format("{:.2f}", 0.001) gives "0.00" without generating any digits. + if (handler.precision <= 0) { + if (handler.precision < 0) return digits::done; + // Divide by 10 to prevent overflow. + uint64_t divisor = data::power_of_10_64[exp - 1] << -one.e; + auto dir = get_round_direction(divisor, value.f / 10, error * 10); + if (dir == round_direction::unknown) return digits::error; + handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0'; + return digits::done; + } + } + // Generate digits for the integral part. This can produce up to 10 digits. + do { + uint32_t digit = 0; + auto divmod_integral = [&](uint32_t divisor) { + digit = integral / divisor; + integral %= divisor; + }; + // This optimization by Milo Yip reduces the number of integer divisions by + // one per iteration. + switch (exp) { + case 10: + divmod_integral(1000000000); + break; + case 9: + divmod_integral(100000000); + break; + case 8: + divmod_integral(10000000); + break; + case 7: + divmod_integral(1000000); + break; + case 6: + divmod_integral(100000); + break; + case 5: + divmod_integral(10000); + break; + case 4: + divmod_integral(1000); + break; + case 3: + divmod_integral(100); + break; + case 2: + divmod_integral(10); + break; + case 1: + digit = integral; + integral = 0; + break; + default: + FMT_ASSERT(false, "invalid number of digits"); + } + --exp; + auto remainder = (static_cast(integral) << -one.e) + fractional; + auto result = handler.on_digit(static_cast('0' + digit), + data::power_of_10_64[exp] << -one.e, + remainder, error, true); + if (result != digits::more) return result; + } while (exp > 0); + // Generate digits for the fractional part. + for (;;) { + fractional *= 10; + error *= 10; + char digit = static_cast('0' + (fractional >> -one.e)); + fractional &= one.f - 1; + --exp; + auto result = handler.on_digit(digit, one.f, fractional, error, false); + if (result != digits::more) return result; + } +} + +class bigint { + private: + // A bigint is stored as an array of bigits (big digits), with bigit at index + // 0 being the least significant one. + using bigit = uint32_t; + using double_bigit = uint64_t; + enum { bigits_capacity = 32 }; + basic_memory_buffer bigits_; + int exp_; + + FMT_CONSTEXPR20 bigit operator[](int index) const { + return bigits_[to_unsigned(index)]; + } + FMT_CONSTEXPR20 bigit& operator[](int index) { + return bigits_[to_unsigned(index)]; + } + + static constexpr const int bigit_bits = num_bits(); + + friend struct formatter; + + FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) { + auto result = static_cast((*this)[index]) - other - borrow; + (*this)[index] = static_cast(result); + borrow = static_cast(result >> (bigit_bits * 2 - 1)); + } + + FMT_CONSTEXPR20 void remove_leading_zeros() { + int num_bigits = static_cast(bigits_.size()) - 1; + while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits; + bigits_.resize(to_unsigned(num_bigits + 1)); + } + + // Computes *this -= other assuming aligned bigints and *this >= other. + FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) { + FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); + FMT_ASSERT(compare(*this, other) >= 0, ""); + bigit borrow = 0; + int i = other.exp_ - exp_; + for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) + subtract_bigits(i, other.bigits_[j], borrow); + while (borrow > 0) subtract_bigits(i, 0, borrow); + remove_leading_zeros(); + } + + FMT_CONSTEXPR20 void multiply(uint32_t value) { + const double_bigit wide_value = value; + bigit carry = 0; + for (size_t i = 0, n = bigits_.size(); i < n; ++i) { + double_bigit result = bigits_[i] * wide_value + carry; + bigits_[i] = static_cast(result); + carry = static_cast(result >> bigit_bits); + } + if (carry != 0) bigits_.push_back(carry); + } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR20 void multiply(UInt value) { + using half_uint = + conditional_t::value, uint64_t, uint32_t>; + const int shift = num_bits() - bigit_bits; + const UInt lower = static_cast(value); + const UInt upper = value >> num_bits(); + UInt carry = 0; + for (size_t i = 0, n = bigits_.size(); i < n; ++i) { + UInt result = lower * bigits_[i] + static_cast(carry); + carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + + (carry >> bigit_bits); + bigits_[i] = static_cast(result); + } + while (carry != 0) { + bigits_.push_back(static_cast(carry)); + carry >>= bigit_bits; + } + } + + template ::value || + std::is_same::value)> + FMT_CONSTEXPR20 void assign(UInt n) { + size_t num_bigits = 0; + do { + bigits_[num_bigits++] = static_cast(n); + n >>= bigit_bits; + } while (n != 0); + bigits_.resize(num_bigits); + exp_ = 0; + } + + public: + FMT_CONSTEXPR20 bigint() : exp_(0) {} + explicit bigint(uint64_t n) { assign(n); } + + bigint(const bigint&) = delete; + void operator=(const bigint&) = delete; + + FMT_CONSTEXPR20 void assign(const bigint& other) { + auto size = other.bigits_.size(); + bigits_.resize(size); + auto data = other.bigits_.data(); + std::copy(data, data + size, make_checked(bigits_.data(), size)); + exp_ = other.exp_; + } + + template FMT_CONSTEXPR20 void operator=(Int n) { + FMT_ASSERT(n > 0, ""); + assign(uint64_or_128_t(n)); + } + + FMT_CONSTEXPR20 int num_bigits() const { + return static_cast(bigits_.size()) + exp_; + } + + FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) { + FMT_ASSERT(shift >= 0, ""); + exp_ += shift / bigit_bits; + shift %= bigit_bits; + if (shift == 0) return *this; + bigit carry = 0; + for (size_t i = 0, n = bigits_.size(); i < n; ++i) { + bigit c = bigits_[i] >> (bigit_bits - shift); + bigits_[i] = (bigits_[i] << shift) + carry; + carry = c; + } + if (carry != 0) bigits_.push_back(carry); + return *this; + } + + template FMT_CONSTEXPR20 bigint& operator*=(Int value) { + FMT_ASSERT(value > 0, ""); + multiply(uint32_or_64_or_128_t(value)); + return *this; + } + + friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) { + int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits(); + if (num_lhs_bigits != num_rhs_bigits) + return num_lhs_bigits > num_rhs_bigits ? 1 : -1; + int i = static_cast(lhs.bigits_.size()) - 1; + int j = static_cast(rhs.bigits_.size()) - 1; + int end = i - j; + if (end < 0) end = 0; + for (; i >= end; --i, --j) { + bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j]; + if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1; + } + if (i != j) return i > j ? 1 : -1; + return 0; + } + + // Returns compare(lhs1 + lhs2, rhs). + friend FMT_CONSTEXPR20 int add_compare(const bigint& lhs1, const bigint& lhs2, + const bigint& rhs) { + auto minimum = [](int a, int b) { return a < b ? a : b; }; + auto maximum = [](int a, int b) { return a > b ? a : b; }; + int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits()); + int num_rhs_bigits = rhs.num_bigits(); + if (max_lhs_bigits + 1 < num_rhs_bigits) return -1; + if (max_lhs_bigits > num_rhs_bigits) return 1; + auto get_bigit = [](const bigint& n, int i) -> bigit { + return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0; + }; + double_bigit borrow = 0; + int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_); + for (int i = num_rhs_bigits - 1; i >= min_exp; --i) { + double_bigit sum = + static_cast(get_bigit(lhs1, i)) + get_bigit(lhs2, i); + bigit rhs_bigit = get_bigit(rhs, i); + if (sum > rhs_bigit + borrow) return 1; + borrow = rhs_bigit + borrow - sum; + if (borrow > 1) return -1; + borrow <<= bigit_bits; + } + return borrow != 0 ? -1 : 0; + } + + // Assigns pow(10, exp) to this bigint. + FMT_CONSTEXPR20 void assign_pow10(int exp) { + FMT_ASSERT(exp >= 0, ""); + if (exp == 0) return *this = 1; + // Find the top bit. + int bitmask = 1; + while (exp >= bitmask) bitmask <<= 1; + bitmask >>= 1; + // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by + // repeated squaring and multiplication. + *this = 5; + bitmask >>= 1; + while (bitmask != 0) { + square(); + if ((exp & bitmask) != 0) *this *= 5; + bitmask >>= 1; + } + *this <<= exp; // Multiply by pow(2, exp) by shifting. + } + + FMT_CONSTEXPR20 void square() { + int num_bigits = static_cast(bigits_.size()); + int num_result_bigits = 2 * num_bigits; + basic_memory_buffer n(std::move(bigits_)); + bigits_.resize(to_unsigned(num_result_bigits)); + auto sum = uint128_t(); + for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) { + // Compute bigit at position bigit_index of the result by adding + // cross-product terms n[i] * n[j] such that i + j == bigit_index. + for (int i = 0, j = bigit_index; j >= 0; ++i, --j) { + // Most terms are multiplied twice which can be optimized in the future. + sum += static_cast(n[i]) * n[j]; + } + (*this)[bigit_index] = static_cast(sum); + sum >>= num_bits(); // Compute the carry. + } + // Do the same for the top half. + for (int bigit_index = num_bigits; bigit_index < num_result_bigits; + ++bigit_index) { + for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) + sum += static_cast(n[i++]) * n[j--]; + (*this)[bigit_index] = static_cast(sum); + sum >>= num_bits(); + } + remove_leading_zeros(); + exp_ *= 2; + } + + // If this bigint has a bigger exponent than other, adds trailing zero to make + // exponents equal. This simplifies some operations such as subtraction. + FMT_CONSTEXPR20 void align(const bigint& other) { + int exp_difference = exp_ - other.exp_; + if (exp_difference <= 0) return; + int num_bigits = static_cast(bigits_.size()); + bigits_.resize(to_unsigned(num_bigits + exp_difference)); + for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) + bigits_[j] = bigits_[i]; + std::uninitialized_fill_n(bigits_.data(), exp_difference, 0); + exp_ -= exp_difference; + } + + // Divides this bignum by divisor, assigning the remainder to this and + // returning the quotient. + FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) { + FMT_ASSERT(this != &divisor, ""); + if (compare(*this, divisor) < 0) return 0; + FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); + align(divisor); + int quotient = 0; + do { + subtract_aligned(divisor); + ++quotient; + } while (compare(*this, divisor) >= 0); + return quotient; + } +}; + +// format_dragon flags. +enum dragon { + predecessor_closer = 1, + fixup = 2, // Run fixup to correct exp10 which can be off by one. + fixed = 4, +}; + +// Formats a floating-point number using a variation of the Fixed-Precision +// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White: +// https://fmt.dev/papers/p372-steele.pdf. +FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, + unsigned flags, int num_digits, + buffer& buf, int& exp10) { + bigint numerator; // 2 * R in (FPP)^2. + bigint denominator; // 2 * S in (FPP)^2. + // lower and upper are differences between value and corresponding boundaries. + bigint lower; // (M^- in (FPP)^2). + bigint upper_store; // upper's value if different from lower. + bigint* upper = nullptr; // (M^+ in (FPP)^2). + // Shift numerator and denominator by an extra bit or two (if lower boundary + // is closer) to make lower and upper integers. This eliminates multiplication + // by 2 during later computations. + bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0; + int shift = is_predecessor_closer ? 2 : 1; + if (value.e >= 0) { + numerator = value.f; + numerator <<= value.e + shift; + lower = 1; + lower <<= value.e; + if (is_predecessor_closer) { + upper_store = 1; + upper_store <<= value.e + 1; + upper = &upper_store; + } + denominator.assign_pow10(exp10); + denominator <<= shift; + } else if (exp10 < 0) { + numerator.assign_pow10(-exp10); + lower.assign(numerator); + if (is_predecessor_closer) { + upper_store.assign(numerator); + upper_store <<= 1; + upper = &upper_store; + } + numerator *= value.f; + numerator <<= shift; + denominator = 1; + denominator <<= shift - value.e; + } else { + numerator = value.f; + numerator <<= shift; + denominator.assign_pow10(exp10); + denominator <<= shift - value.e; + lower = 1; + if (is_predecessor_closer) { + upper_store = 1ULL << 1; + upper = &upper_store; + } + } + int even = static_cast((value.f & 1) == 0); + if (!upper) upper = &lower; + if ((flags & dragon::fixup) != 0) { + if (add_compare(numerator, *upper, denominator) + even <= 0) { + --exp10; + numerator *= 10; + if (num_digits < 0) { + lower *= 10; + if (upper != &lower) *upper *= 10; + } + } + if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1); + } + // Invariant: value == (numerator / denominator) * pow(10, exp10). + if (num_digits < 0) { + // Generate the shortest representation. + num_digits = 0; + char* data = buf.data(); + for (;;) { + int digit = numerator.divmod_assign(denominator); + bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower. + // numerator + upper >[=] pow10: + bool high = add_compare(numerator, *upper, denominator) + even > 0; + data[num_digits++] = static_cast('0' + digit); + if (low || high) { + if (!low) { + ++data[num_digits - 1]; + } else if (high) { + int result = add_compare(numerator, numerator, denominator); + // Round half to even. + if (result > 0 || (result == 0 && (digit % 2) != 0)) + ++data[num_digits - 1]; + } + buf.try_resize(to_unsigned(num_digits)); + exp10 -= num_digits - 1; + return; + } + numerator *= 10; + lower *= 10; + if (upper != &lower) *upper *= 10; + } + } + // Generate the given number of digits. + exp10 -= num_digits - 1; + if (num_digits == 0) { + denominator *= 10; + auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; + buf.push_back(digit); + return; + } + buf.try_resize(to_unsigned(num_digits)); + for (int i = 0; i < num_digits - 1; ++i) { + int digit = numerator.divmod_assign(denominator); + buf[i] = static_cast('0' + digit); + numerator *= 10; + } + int digit = numerator.divmod_assign(denominator); + auto result = add_compare(numerator, numerator, denominator); + if (result > 0 || (result == 0 && (digit % 2) != 0)) { + if (digit == 9) { + const auto overflow = '0' + 10; + buf[num_digits - 1] = overflow; + // Propagate the carry. + for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) { + buf[i] = '0'; + ++buf[i - 1]; + } + if (buf[0] == overflow) { + buf[0] = '1'; + ++exp10; + } + return; + } + ++digit; + } + buf[num_digits - 1] = static_cast('0' + digit); +} + +// Formats a floating-point number using the hexfloat format. +template ::value)> +FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, + float_specs specs, buffer& buf) { + // float is passed as double to reduce the number of instantiations and to + // simplify implementation. + static_assert(!std::is_same::value, ""); + + using info = dragonbox::float_info; + + // Assume Float is in the format [sign][exponent][significand]. + using carrier_uint = typename info::carrier_uint; + + constexpr auto num_float_significand_bits = + detail::num_significand_bits(); + + basic_fp f(value); + f.e += num_float_significand_bits; + if (!has_implicit_bit()) --f.e; + + constexpr auto num_fraction_bits = + num_float_significand_bits + (has_implicit_bit() ? 1 : 0); + constexpr auto num_xdigits = (num_fraction_bits + 3) / 4; + + constexpr auto leading_shift = ((num_xdigits - 1) * 4); + const auto leading_mask = carrier_uint(0xF) << leading_shift; + const auto leading_xdigit = + static_cast((f.f & leading_mask) >> leading_shift); + if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); + + int print_xdigits = num_xdigits - 1; + if (precision >= 0 && print_xdigits > precision) { + const int shift = ((print_xdigits - precision - 1) * 4); + const auto mask = carrier_uint(0xF) << shift; + const auto v = static_cast((f.f & mask) >> shift); + + if (v >= 8) { + const auto inc = carrier_uint(1) << (shift + 4); + f.f += inc; + f.f &= ~(inc - 1); + } + + // Check long double overflow + if (!has_implicit_bit()) { + const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; + if ((f.f & implicit_bit) == implicit_bit) { + f.f >>= 4; + f.e += 4; + } + } + + print_xdigits = precision; + } + + char xdigits[num_bits() / 4]; + detail::fill_n(xdigits, sizeof(xdigits), '0'); + format_uint<4>(xdigits, f.f, num_xdigits, specs.upper); + + // Remove zero tail + while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits; + + buf.push_back('0'); + buf.push_back(specs.upper ? 'X' : 'x'); + buf.push_back(xdigits[0]); + if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision) + buf.push_back('.'); + buf.append(xdigits + 1, xdigits + 1 + print_xdigits); + for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0'); + + buf.push_back(specs.upper ? 'P' : 'p'); + + uint32_t abs_e; + if (f.e < 0) { + buf.push_back('-'); + abs_e = static_cast(-f.e); + } else { + buf.push_back('+'); + abs_e = static_cast(f.e); + } + format_decimal(appender(buf), abs_e, detail::count_digits(abs_e)); +} + +template ::value)> +FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision, + float_specs specs, buffer& buf) { + format_hexfloat(static_cast(value), precision, specs, buf); +} + +template +FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs, + buffer& buf) -> int { + // float is passed as double to reduce the number of instantiations. + static_assert(!std::is_same::value, ""); + FMT_ASSERT(value >= 0, "value is negative"); + auto converted_value = convert_float(value); + + const bool fixed = specs.format == float_format::fixed; + if (value <= 0) { // <= instead of == to silence a warning. + if (precision <= 0 || !fixed) { + buf.push_back('0'); + return 0; + } + buf.try_resize(to_unsigned(precision)); + fill_n(buf.data(), precision, '0'); + return -precision; + } + + int exp = 0; + bool use_dragon = true; + unsigned dragon_flags = 0; + if (!is_fast_float()) { + const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) + using info = dragonbox::float_info; + const auto f = basic_fp(converted_value); + // Compute exp, an approximate power of 10, such that + // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). + // This is based on log10(value) == log2(value) / log2(10) and approximation + // of log2(value) by e + num_fraction_bits idea from double-conversion. + exp = static_cast( + std::ceil((f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10)); + dragon_flags = dragon::fixup; + } else if (!is_constant_evaluated() && precision < 0) { + // Use Dragonbox for the shortest format. + if (specs.binary32) { + auto dec = dragonbox::to_decimal(static_cast(value)); + write(buffer_appender(buf), dec.significand); + return dec.exponent; + } + auto dec = dragonbox::to_decimal(static_cast(value)); + write(buffer_appender(buf), dec.significand); + return dec.exponent; + } else if (is_constant_evaluated()) { + // Use Grisu + Dragon4 for the given precision: + // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf. + const int min_exp = -60; // alpha in Grisu. + int cached_exp10 = 0; // K in Grisu. + fp normalized = normalize(fp(converted_value)); + const auto cached_pow = get_cached_power( + min_exp - (normalized.e + fp::num_significand_bits), cached_exp10); + normalized = normalized * cached_pow; + gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed}; + if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error && + !is_constant_evaluated()) { + exp += handler.exp10; + buf.try_resize(to_unsigned(handler.size)); + use_dragon = false; + } else { + exp += handler.size - cached_exp10 - 1; + precision = handler.precision; + } + } else { + // Extract significand bits and exponent bits. + using info = dragonbox::float_info; + auto br = bit_cast(static_cast(value)); + + const uint64_t significand_mask = + (static_cast(1) << num_significand_bits()) - 1; + uint64_t significand = (br & significand_mask); + int exponent = static_cast((br & exponent_mask()) >> + num_significand_bits()); + + if (exponent != 0) { // Check if normal. + exponent -= exponent_bias() + num_significand_bits(); + significand |= + (static_cast(1) << num_significand_bits()); + significand <<= 1; + } else { + // Normalize subnormal inputs. + FMT_ASSERT(significand != 0, "zeros should not appear hear"); + int shift = countl_zero(significand); + FMT_ASSERT(shift >= num_bits() - num_significand_bits(), + ""); + shift -= (num_bits() - num_significand_bits() - 2); + exponent = (std::numeric_limits::min_exponent - + num_significand_bits()) - + shift; + significand <<= shift; + } + + // Compute the first several nonzero decimal significand digits. + // We call the number we get the first segment. + const int k = info::kappa - dragonbox::floor_log10_pow2(exponent); + exp = -k; + const int beta = exponent + dragonbox::floor_log2_pow10(k); + uint64_t first_segment; + bool has_more_segments; + int digits_in_the_first_segment; + { + const auto r = dragonbox::umul192_upper128( + significand << beta, dragonbox::get_cached_power(k)); + first_segment = r.high(); + has_more_segments = r.low() != 0; + + // The first segment can have 18 ~ 19 digits. + if (first_segment >= 1000000000000000000ULL) { + digits_in_the_first_segment = 19; + } else { + // When it is of 18-digits, we align it to 19-digits by adding a bogus + // zero at the end. + digits_in_the_first_segment = 18; + first_segment *= 10; + } + } + + // Compute the actual number of decimal digits to print. + if (fixed) { + adjust_precision(precision, exp + digits_in_the_first_segment); + } + + // Use Dragon4 only when there might be not enough digits in the first + // segment. + if (digits_in_the_first_segment > precision) { + use_dragon = false; + + if (precision <= 0) { + exp += digits_in_the_first_segment; + + if (precision < 0) { + // Nothing to do, since all we have are just leading zeros. + buf.try_resize(0); + } else { + // We may need to round-up. + buf.try_resize(1); + if ((first_segment | static_cast(has_more_segments)) > + 5000000000000000000ULL) { + buf[0] = '1'; + } else { + buf[0] = '0'; + } + } + } // precision <= 0 + else { + exp += digits_in_the_first_segment - precision; + + // When precision > 0, we divide the first segment into three + // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits + // in 32-bits which usually allows faster calculation than in + // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize + // division-by-constant for large 64-bit divisors, we do it here + // manually. The magic number 7922816251426433760 below is equal to + // ceil(2^(64+32) / 10^10). + const uint32_t first_subsegment = static_cast( + dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >> + 32); + const uint64_t second_third_subsegments = + first_segment - first_subsegment * 10000000000ULL; + + uint64_t prod; + uint32_t digits; + bool should_round_up; + int number_of_digits_to_print = precision > 9 ? 9 : precision; + + // Print a 9-digits subsegment, either the first or the second. + auto print_subsegment = [&](uint32_t subsegment, char* buffer) { + int number_of_digits_printed = 0; + + // If we want to print an odd number of digits from the subsegment, + if ((number_of_digits_to_print & 1) != 0) { + // Convert to 64-bit fixed-point fractional form with 1-digit + // integer part. The magic number 720575941 is a good enough + // approximation of 2^(32 + 24) / 10^8; see + // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case + // for details. + prod = ((subsegment * static_cast(720575941)) >> 24) + 1; + digits = static_cast(prod >> 32); + *buffer = static_cast('0' + digits); + number_of_digits_printed++; + } + // If we want to print an even number of digits from the + // first_subsegment, + else { + // Convert to 64-bit fixed-point fractional form with 2-digits + // integer part. The magic number 450359963 is a good enough + // approximation of 2^(32 + 20) / 10^7; see + // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case + // for details. + prod = ((subsegment * static_cast(450359963)) >> 20) + 1; + digits = static_cast(prod >> 32); + copy2(buffer, digits2(digits)); + number_of_digits_printed += 2; + } + + // Print all digit pairs. + while (number_of_digits_printed < number_of_digits_to_print) { + prod = static_cast(prod) * static_cast(100); + digits = static_cast(prod >> 32); + copy2(buffer + number_of_digits_printed, digits2(digits)); + number_of_digits_printed += 2; + } + }; + + // Print first subsegment. + print_subsegment(first_subsegment, buf.data()); + + // Perform rounding if the first subsegment is the last subsegment to + // print. + if (precision <= 9) { + // Rounding inside the subsegment. + // We round-up if: + // - either the fractional part is strictly larger than 1/2, or + // - the fractional part is exactly 1/2 and the last digit is odd. + // We rely on the following observations: + // - If fractional_part >= threshold, then the fractional part is + // strictly larger than 1/2. + // - If the MSB of fractional_part is set, then the fractional part + // must be at least 1/2. + // - When the MSB of fractional_part is set, either + // second_third_subsegments being nonzero or has_more_segments + // being true means there are further digits not printed, so the + // fractional part is strictly larger than 1/2. + if (precision < 9) { + uint32_t fractional_part = static_cast(prod); + should_round_up = fractional_part >= + data::fractional_part_rounding_thresholds + [8 - number_of_digits_to_print] || + ((fractional_part >> 31) & + ((digits & 1) | (second_third_subsegments != 0) | + has_more_segments)) != 0; + } + // Rounding at the subsegment boundary. + // In this case, the fractional part is at least 1/2 if and only if + // second_third_subsegments >= 5000000000ULL, and is strictly larger + // than 1/2 if we further have either second_third_subsegments > + // 5000000000ULL or has_more_segments == true. + else { + should_round_up = second_third_subsegments > 5000000000ULL || + (second_third_subsegments == 5000000000ULL && + ((digits & 1) != 0 || has_more_segments)); + } + } + // Otherwise, print the second subsegment. + else { + // Compilers are not aware of how to leverage the maximum value of + // second_third_subsegments to find out a better magic number which + // allows us to eliminate an additional shift. 1844674407370955162 = + // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))). + const uint32_t second_subsegment = + static_cast(dragonbox::umul128_upper64( + second_third_subsegments, 1844674407370955162ULL)); + const uint32_t third_subsegment = + static_cast(second_third_subsegments) - + second_subsegment * 10; + + number_of_digits_to_print = precision - 9; + print_subsegment(second_subsegment, buf.data() + 9); + + // Rounding inside the subsegment. + if (precision < 18) { + // The condition third_subsegment != 0 implies that the segment was + // of 19 digits, so in this case the third segment should be + // consisting of a genuine digit from the input. + uint32_t fractional_part = static_cast(prod); + should_round_up = fractional_part >= + data::fractional_part_rounding_thresholds + [8 - number_of_digits_to_print] || + ((fractional_part >> 31) & + ((digits & 1) | (third_subsegment != 0) | + has_more_segments)) != 0; + } + // Rounding at the subsegment boundary. + else { + // In this case, the segment must be of 19 digits, thus + // the third subsegment should be consisting of a genuine digit from + // the input. + should_round_up = third_subsegment > 5 || + (third_subsegment == 5 && + ((digits & 1) != 0 || has_more_segments)); + } + } + + // Round-up if necessary. + if (should_round_up) { + ++buf[precision - 1]; + for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) { + buf[i] = '0'; + ++buf[i - 1]; + } + if (buf[0] > '9') { + buf[0] = '1'; + if (fixed) + buf[precision++] = '0'; + else + ++exp; + } + } + buf.try_resize(to_unsigned(precision)); + } + } // if (digits_in_the_first_segment > precision) + else { + // Adjust the exponent for its use in Dragon4. + exp += digits_in_the_first_segment - 1; + } + } + if (use_dragon) { + auto f = basic_fp(); + bool is_predecessor_closer = specs.binary32 + ? f.assign(static_cast(value)) + : f.assign(converted_value); + if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer; + if (fixed) dragon_flags |= dragon::fixed; + // Limit precision to the maximum possible number of significant digits in + // an IEEE754 double because we don't need to generate zeros. + const int max_double_digits = 767; + if (precision > max_double_digits) precision = max_double_digits; + format_dragon(f, dragon_flags, precision, buf, exp); + } + if (!fixed && !specs.showpoint) { + // Remove trailing zeros. + auto num_digits = buf.size(); + while (num_digits > 0 && buf[num_digits - 1] == '0') { + --num_digits; + ++exp; + } + buf.try_resize(num_digits); + } + return exp; +} +template +FMT_CONSTEXPR20 auto write_float(OutputIt out, T value, + format_specs specs, locale_ref loc) + -> OutputIt { + float_specs fspecs = parse_float_type_spec(specs); + fspecs.sign = specs.sign; + if (detail::signbit(value)) { // value < 0 is false for NaN so use signbit. + fspecs.sign = sign::minus; + value = -value; + } else if (fspecs.sign == sign::minus) { + fspecs.sign = sign::none; + } + + if (!detail::isfinite(value)) + return write_nonfinite(out, detail::isnan(value), specs, fspecs); + + if (specs.align == align::numeric && fspecs.sign) { + auto it = reserve(out, 1); + *it++ = detail::sign(fspecs.sign); + out = base_iterator(out, it); + fspecs.sign = sign::none; + if (specs.width != 0) --specs.width; + } + + memory_buffer buffer; + if (fspecs.format == float_format::hex) { + if (fspecs.sign) buffer.push_back(detail::sign(fspecs.sign)); + format_hexfloat(convert_float(value), specs.precision, fspecs, buffer); + return write_bytes(out, {buffer.data(), buffer.size()}, + specs); + } + int precision = specs.precision >= 0 || specs.type == presentation_type::none + ? specs.precision + : 6; + if (fspecs.format == float_format::exp) { + if (precision == max_value()) + throw_format_error("number is too big"); + else + ++precision; + } else if (fspecs.format != float_format::fixed && precision == 0) { + precision = 1; + } + if (const_check(std::is_same())) fspecs.binary32 = true; + int exp = format_float(convert_float(value), precision, fspecs, buffer); + fspecs.precision = precision; + auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp}; + return write_float(out, f, specs, fspecs, loc); +} + +template ::value)> +FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, + locale_ref loc = {}) -> OutputIt { + if (const_check(!is_supported_floating_point(value))) return out; + return specs.localized && write_loc(out, value, specs, loc) + ? out + : write_float(out, value, specs, loc); +} + +template ::value)> +FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { + if (is_constant_evaluated()) return write(out, value, format_specs()); + if (const_check(!is_supported_floating_point(value))) return out; + + auto fspecs = float_specs(); + if (detail::signbit(value)) { + fspecs.sign = sign::minus; + value = -value; + } + + constexpr auto specs = format_specs(); + using floaty = conditional_t::value, double, T>; + using floaty_uint = typename dragonbox::float_info::carrier_uint; + floaty_uint mask = exponent_mask(); + if ((bit_cast(value) & mask) == mask) + return write_nonfinite(out, std::isnan(value), specs, fspecs); + + auto dec = dragonbox::to_decimal(static_cast(value)); + return write_float(out, dec, specs, fspecs, {}); +} + +template ::value && + !is_fast_float::value)> +inline auto write(OutputIt out, T value) -> OutputIt { + return write(out, value, format_specs()); +} + +template +auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) + -> OutputIt { + FMT_ASSERT(false, ""); + return out; +} + +template +FMT_CONSTEXPR auto write(OutputIt out, basic_string_view value) + -> OutputIt { + auto it = reserve(out, value.size()); + it = copy_str_noinline(value.begin(), value.end(), it); + return base_iterator(out, it); +} + +template ::value)> +constexpr auto write(OutputIt out, const T& value) -> OutputIt { + return write(out, to_string_view(value)); +} + +// FMT_ENABLE_IF() condition separated to workaround an MSVC bug. +template < + typename Char, typename OutputIt, typename T, + bool check = + std::is_enum::value && !std::is_same::value && + mapped_type_constant>::value != + type::custom_type, + FMT_ENABLE_IF(check)> +FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { + return write(out, static_cast>(value)); +} + +template ::value)> +FMT_CONSTEXPR auto write(OutputIt out, T value, + const format_specs& specs = {}, locale_ref = {}) + -> OutputIt { + return specs.type != presentation_type::none && + specs.type != presentation_type::string + ? write(out, value ? 1 : 0, specs, {}) + : write_bytes(out, value ? "true" : "false", specs); +} + +template +FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { + auto it = reserve(out, 1); + *it++ = value; + return base_iterator(out, it); +} + +template +FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value) + -> OutputIt { + if (value) return write(out, basic_string_view(value)); + throw_format_error("string pointer is null"); + return out; +} + +template ::value)> +auto write(OutputIt out, const T* value, const format_specs& specs = {}, + locale_ref = {}) -> OutputIt { + return write_ptr(out, bit_cast(value), &specs); +} + +// A write overload that handles implicit conversions. +template > +FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t< + std::is_class::value && !is_string::value && + !is_floating_point::value && !std::is_same::value && + !std::is_same().map( + value))>>::value, + OutputIt> { + return write(out, arg_mapper().map(value)); +} + +template > +FMT_CONSTEXPR auto write(OutputIt out, const T& value) + -> enable_if_t::value == type::custom_type, + OutputIt> { + auto ctx = Context(out, {}, {}); + return typename Context::template formatter_type().format(value, ctx); +} + +// An argument visitor that formats the argument and writes it via the output +// iterator. It's a class and not a generic lambda for compatibility with C++11. +template struct default_arg_formatter { + using iterator = buffer_appender; + using context = buffer_context; + + iterator out; + basic_format_args args; + locale_ref loc; + + template auto operator()(T value) -> iterator { + return write(out, value); + } + auto operator()(typename basic_format_arg::handle h) -> iterator { + basic_format_parse_context parse_ctx({}); + context format_ctx(out, args, loc); + h.format(parse_ctx, format_ctx); + return format_ctx.out(); + } +}; + +template struct arg_formatter { + using iterator = buffer_appender; + using context = buffer_context; + + iterator out; + const format_specs& specs; + locale_ref locale; + + template + FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator { + return detail::write(out, value, specs, locale); + } + auto operator()(typename basic_format_arg::handle) -> iterator { + // User-defined types are handled separately because they require access + // to the parse context. + return out; + } +}; + +template struct custom_formatter { + basic_format_parse_context& parse_ctx; + buffer_context& ctx; + + void operator()( + typename basic_format_arg>::handle h) const { + h.format(parse_ctx, ctx); + } + template void operator()(T) const {} +}; + +template class width_checker { + public: + explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {} + + template ::value)> + FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { + if (is_negative(value)) handler_.on_error("negative width"); + return static_cast(value); + } + + template ::value)> + FMT_CONSTEXPR auto operator()(T) -> unsigned long long { + handler_.on_error("width is not integer"); + return 0; + } + + private: + ErrorHandler& handler_; +}; + +template class precision_checker { + public: + explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {} + + template ::value)> + FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { + if (is_negative(value)) handler_.on_error("negative precision"); + return static_cast(value); + } + + template ::value)> + FMT_CONSTEXPR auto operator()(T) -> unsigned long long { + handler_.on_error("precision is not integer"); + return 0; + } + + private: + ErrorHandler& handler_; +}; + +template