mirror of
https://git.savannah.gnu.org/git/coreutils.git
synced 2026-11-17 18:02:09 +03:00
maint: remove need for mbsalign
This simplifies memory allocation a bit, and removes an arbitrary limitation from numfmt, which formerly limited cell output to 127 bytes. * bootstrap.conf (gnulib_modules): Remove mbsalign, strncat. Add strnlen (the code already used strnlen directly, and we were saved only because Gnulib used the module indirectly) * gl/lib/mbsalign.c, gl/lib/mbsalign.h, gl/modules/mbsalign: * gl/modules/mbsalign-tests, gl/tests/test-mbsalign.c: Remove. * src/df.c, src/ls.c: Do not include mbsalign.h. (MBSWIDTH_FLAGS): New constant, now used for all mbswidth calls. All callers changed to check for -1 return. * src/df.c (struct field_data_t): ‘width’ is now int not size_t, since mbswidth can’t do widths greater than INT_MAX anyway. Replace ‘align’ with ‘align_right’. All uses changed. (print_table): Redo to avoid the need for ambsalign. (get_header, get_dev): mbswidth returns int, not size_t. * src/ls.c (MAX_MON_WIDTH): Remove; no longer used. (abmon_init): Use strnlen to cheaply discard too-long month names. Align by hand instead of using mbsalign. * src/numfmt.c: Include stdckdint.h, mbswidth.h. Do not include mbsalign.h. (padding_buffer_size): Now idx_t. All uses changed. (padding_width): Now intmax_t, since it’s no longer an object size. Its sign now records alignment. All uses changed. (zero_padding_width): Now int, since it’s given to sprintf. All uses changed. (padding_alignment): Remove; it’s now taken from padding_width’s sign. (double_to_human): Return string length. BUF_SIZE arg is now idx_t. Include suffix in output. All callers changed. Simplify by not calling strncat or stpcpy. Calculate fmt size bound more carefully. (setup_padding_buffer): Remove. All uses removed. (parse_format_string): Use intmax_t, not long, for pad. On overflow, set widths to large values that cause later code to do the right thing, rather than separately checking for overflow here. (prepare_padded_number): Return bool, not int 0/1. New arg PADDING. All uses changed. Do not limit padded output to 127 bytes; instead, use xpalloc to expand the output buffer. (print_padded_number): New arg PADDING. All uses changed. (process_suffixed_number): Simplify. (main): Take extremum if xstrtoimax overflows, as this does the right thing. * tests/misc/numfmt.pl: New test suf-20 to test for truncation bug. Remove tests pad-3.2, fmt-err-7, as they’re no longer invalid but are quite expensive.
This commit is contained in:
1 parent
632beba630
commit
cbb6dfec55
10 files changed
+172
-709
No files matched your search
+1
-2
@@ -169,7 +169,6 @@ gnulib_modules="
|
||||
manywarnings
|
||||
mbrlen
|
||||
mbrtowc
|
||||
mbsalign
|
||||
mbschr
|
||||
mbslen
|
||||
mbswidth
|
||||
@@ -259,7 +258,7 @@ gnulib_modules="
|
||||
stpcpy
|
||||
stpncpy
|
||||
strdup-posix
|
||||
strncat
|
||||
strnlen
|
||||
strnumcmp
|
||||
strsignal
|
||||
strtoimax
|
||||
|
||||
@@ -1,275 +0,0 @@
|
||||
/* Align/Truncate a string in a given screen width
|
||||
Copyright (C) 2009-2023 Free Software Foundation, Inc.
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
||||
|
||||
/* Written by Pádraig Brady. */
|
||||
|
||||
#include <config.h>
|
||||
#include "mbsalign.h"
|
||||
|
||||
#include "minmax.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <limits.h>
|
||||
#include <wchar.h>
|
||||
#include <wctype.h>
|
||||
|
||||
/* Replace non printable chars.
|
||||
Note \t and \n etc. are non printable.
|
||||
Return 1 if replacement made, 0 otherwise. */
|
||||
|
||||
static bool
|
||||
wc_ensure_printable (wchar_t *wchars)
|
||||
{
|
||||
bool replaced = false;
|
||||
wchar_t *wc = wchars;
|
||||
while (*wc)
|
||||
{
|
||||
if (!iswprint ((wint_t) *wc))
|
||||
{
|
||||
*wc = 0xFFFD; /* L'\uFFFD' (replacement char) */
|
||||
replaced = true;
|
||||
}
|
||||
wc++;
|
||||
}
|
||||
return replaced;
|
||||
}
|
||||
|
||||
/* Truncate wchar string to width cells.
|
||||
* Returns number of cells used. */
|
||||
|
||||
static size_t
|
||||
wc_truncate (wchar_t *wc, size_t width)
|
||||
{
|
||||
size_t cells = 0;
|
||||
int next_cells = 0;
|
||||
|
||||
while (*wc)
|
||||
{
|
||||
next_cells = wcwidth (*wc);
|
||||
if (next_cells == -1) /* non printable */
|
||||
{
|
||||
*wc = 0xFFFD; /* L'\uFFFD' (replacement char) */
|
||||
next_cells = 1;
|
||||
}
|
||||
if (cells + next_cells > width)
|
||||
break;
|
||||
cells += next_cells;
|
||||
wc++;
|
||||
}
|
||||
*wc = L'\0';
|
||||
return cells;
|
||||
}
|
||||
|
||||
/* Write N_SPACES space characters to DEST while ensuring
|
||||
nothing is written beyond DEST_END. A terminating NUL
|
||||
is always added to DEST.
|
||||
A pointer to the terminating NUL is returned. */
|
||||
|
||||
static char *
|
||||
mbs_align_pad (char *dest, char const *dest_end, size_t n_spaces)
|
||||
{
|
||||
/* FIXME: Should we pad with "figure space" (\u2007)
|
||||
if non ascii data present? */
|
||||
while (n_spaces-- && (dest < dest_end))
|
||||
*dest++ = ' ';
|
||||
*dest = '\0';
|
||||
return dest;
|
||||
}
|
||||
|
||||
/* Align a string, SRC, in a field of *WIDTH columns, handling multi-byte
|
||||
characters; write the result into the DEST_SIZE-byte buffer, DEST.
|
||||
ALIGNMENT specifies whether to left- or right-justify or to center.
|
||||
If SRC requires more than *WIDTH columns, truncate it to fit.
|
||||
When centering, the number of trailing spaces may be one less than the
|
||||
number of leading spaces.
|
||||
Return the length in bytes required for the final result, not counting
|
||||
the trailing NUL. A return value of DEST_SIZE or larger means there
|
||||
wasn't enough space. DEST will be NUL terminated in any case.
|
||||
Return SIZE_MAX upon error (invalid multi-byte sequence in SRC,
|
||||
or malloc failure), unless MBA_UNIBYTE_FALLBACK is specified.
|
||||
Update *WIDTH to indicate how many columns were used before padding. */
|
||||
|
||||
size_t
|
||||
mbsalign (char const *src, char *dest, size_t dest_size,
|
||||
size_t *width, mbs_align_t align, int flags)
|
||||
{
|
||||
size_t ret = SIZE_MAX;
|
||||
size_t src_size = strlen (src) + 1;
|
||||
char *newstr = nullptr;
|
||||
wchar_t *str_wc = nullptr;
|
||||
char const *str_to_print = src;
|
||||
size_t n_cols = src_size - 1;
|
||||
size_t n_used_bytes = n_cols; /* Not including NUL */
|
||||
size_t n_spaces = 0;
|
||||
bool conversion = false;
|
||||
bool wc_enabled = false;
|
||||
|
||||
/* In multi-byte locales convert to wide characters
|
||||
to allow easy truncation. Also determine number
|
||||
of screen columns used. */
|
||||
if (!(flags & MBA_UNIBYTE_ONLY) && MB_CUR_MAX > 1)
|
||||
{
|
||||
size_t src_chars = mbstowcs (nullptr, src, 0);
|
||||
if (src_chars == SIZE_MAX)
|
||||
{
|
||||
if (flags & MBA_UNIBYTE_FALLBACK)
|
||||
goto mbsalign_unibyte;
|
||||
else
|
||||
goto mbsalign_cleanup;
|
||||
}
|
||||
src_chars += 1; /* make space for NUL */
|
||||
str_wc = malloc (src_chars * sizeof (wchar_t));
|
||||
if (str_wc == nullptr)
|
||||
{
|
||||
if (flags & MBA_UNIBYTE_FALLBACK)
|
||||
goto mbsalign_unibyte;
|
||||
else
|
||||
goto mbsalign_cleanup;
|
||||
}
|
||||
if (mbstowcs (str_wc, src, src_chars) != 0)
|
||||
{
|
||||
str_wc[src_chars - 1] = L'\0';
|
||||
wc_enabled = true;
|
||||
conversion = wc_ensure_printable (str_wc);
|
||||
n_cols = wcswidth (str_wc, src_chars);
|
||||
}
|
||||
}
|
||||
|
||||
/* If we transformed or need to truncate the source string
|
||||
then create a modified copy of it. */
|
||||
if (wc_enabled && (conversion || (n_cols > *width)))
|
||||
{
|
||||
if (conversion)
|
||||
{
|
||||
/* May have increased the size by converting
|
||||
\t to \uFFFD for example. */
|
||||
src_size = wcstombs (nullptr, str_wc, 0) + 1;
|
||||
}
|
||||
newstr = malloc (src_size);
|
||||
if (newstr == nullptr)
|
||||
{
|
||||
if (flags & MBA_UNIBYTE_FALLBACK)
|
||||
goto mbsalign_unibyte;
|
||||
else
|
||||
goto mbsalign_cleanup;
|
||||
}
|
||||
str_to_print = newstr;
|
||||
n_cols = wc_truncate (str_wc, *width);
|
||||
n_used_bytes = wcstombs (newstr, str_wc, src_size);
|
||||
}
|
||||
|
||||
mbsalign_unibyte:
|
||||
|
||||
if (n_cols > *width) /* Unibyte truncation required. */
|
||||
{
|
||||
n_cols = *width;
|
||||
n_used_bytes = n_cols;
|
||||
}
|
||||
|
||||
if (*width > n_cols) /* Padding required. */
|
||||
n_spaces = *width - n_cols;
|
||||
|
||||
/* indicate to caller how many cells needed (not including padding). */
|
||||
*width = n_cols;
|
||||
|
||||
{
|
||||
size_t start_spaces, end_spaces;
|
||||
|
||||
switch (align)
|
||||
{
|
||||
case MBS_ALIGN_LEFT:
|
||||
start_spaces = 0;
|
||||
end_spaces = n_spaces;
|
||||
break;
|
||||
case MBS_ALIGN_RIGHT:
|
||||
start_spaces = n_spaces;
|
||||
end_spaces = 0;
|
||||
break;
|
||||
case MBS_ALIGN_CENTER:
|
||||
default:
|
||||
start_spaces = n_spaces / 2 + n_spaces % 2;
|
||||
end_spaces = n_spaces / 2;
|
||||
break;
|
||||
}
|
||||
|
||||
if (flags & MBA_NO_LEFT_PAD)
|
||||
start_spaces = 0;
|
||||
if (flags & MBA_NO_RIGHT_PAD)
|
||||
end_spaces = 0;
|
||||
|
||||
/* Write as much NUL terminated output to DEST as possible. */
|
||||
if (dest_size != 0)
|
||||
{
|
||||
size_t space_left;
|
||||
char *dest_end = dest + dest_size - 1;
|
||||
|
||||
dest = mbs_align_pad (dest, dest_end, start_spaces);
|
||||
space_left = dest_end - dest;
|
||||
dest = mempcpy (dest, str_to_print, MIN (n_used_bytes, space_left));
|
||||
mbs_align_pad (dest, dest_end, end_spaces);
|
||||
}
|
||||
|
||||
/* indicate to caller how many bytes needed (not including NUL). */
|
||||
ret = n_used_bytes + ((start_spaces + end_spaces) * 1);
|
||||
}
|
||||
|
||||
mbsalign_cleanup:
|
||||
|
||||
free (str_wc);
|
||||
free (newstr);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* A wrapper around mbsalign() to dynamically allocate the
|
||||
minimum amount of memory to store the result.
|
||||
Return nullptr on failure. */
|
||||
|
||||
char *
|
||||
ambsalign (char const *src, size_t *width, mbs_align_t align, int flags)
|
||||
{
|
||||
size_t orig_width = *width;
|
||||
size_t size = *width; /* Start with enough for unibyte mode. */
|
||||
size_t req = size;
|
||||
char *buf = nullptr;
|
||||
|
||||
while (req >= size)
|
||||
{
|
||||
char *nbuf;
|
||||
size = req + 1; /* Space for NUL. */
|
||||
nbuf = realloc (buf, size);
|
||||
if (nbuf == nullptr)
|
||||
{
|
||||
free (buf);
|
||||
buf = nullptr;
|
||||
break;
|
||||
}
|
||||
buf = nbuf;
|
||||
*width = orig_width;
|
||||
req = mbsalign (src, buf, size, width, align, flags);
|
||||
if (req == SIZE_MAX)
|
||||
{
|
||||
free (buf);
|
||||
buf = nullptr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
/* Align/Truncate a string in a given screen width
|
||||
Copyright (C) 2009-2023 Free Software Foundation, Inc.
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef enum { MBS_ALIGN_LEFT, MBS_ALIGN_RIGHT, MBS_ALIGN_CENTER } mbs_align_t;
|
||||
|
||||
enum {
|
||||
/* Use unibyte mode for invalid multibyte strings
|
||||
or when heap memory is exhausted. */
|
||||
MBA_UNIBYTE_FALLBACK = 0x0001,
|
||||
|
||||
/* As an optimization, don't do multibyte processing
|
||||
when we know no multibyte characters are present. */
|
||||
MBA_UNIBYTE_ONLY = 0x0002,
|
||||
|
||||
/* Don't add leading padding. */
|
||||
MBA_NO_LEFT_PAD = 0x0004,
|
||||
|
||||
/* Don't add trailing padding. */
|
||||
MBA_NO_RIGHT_PAD = 0x0008
|
||||
|
||||
#if 0 /* Other possible options. */
|
||||
/* Skip invalid multibyte chars rather than failing. */
|
||||
MBA_IGNORE_INVALID
|
||||
|
||||
/* Align multibyte strings using "figure space" (\u2007). */
|
||||
MBA_USE_FIGURE_SPACE
|
||||
|
||||
/* Don't truncate. */
|
||||
MBA_NO_TRUNCATE
|
||||
|
||||
/* Ensure no leading whitespace. */
|
||||
MBA_LSTRIP
|
||||
|
||||
/* Ensure no trailing whitespace. */
|
||||
MBA_RSTRIP
|
||||
#endif
|
||||
};
|
||||
|
||||
size_t
|
||||
mbsalign (char const *src, char *dest, size_t dest_size,
|
||||
size_t *width, mbs_align_t align, int flags)
|
||||
_GL_ATTRIBUTE_NONNULL ();
|
||||
|
||||
char *
|
||||
ambsalign (char const *src, size_t *width, mbs_align_t align, int flags)
|
||||
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
|
||||
_GL_ATTRIBUTE_NONNULL ();
|
||||
@@ -1,28 +0,0 @@
|
||||
Description:
|
||||
Align/Truncate a string in a given screen width.
|
||||
|
||||
Files:
|
||||
lib/mbsalign.c
|
||||
lib/mbsalign.h
|
||||
|
||||
Depends-on:
|
||||
minmax
|
||||
wchar
|
||||
wctype
|
||||
wcwidth
|
||||
mempcpy
|
||||
stdint
|
||||
|
||||
configure.ac:
|
||||
|
||||
Makefile.am:
|
||||
lib_SOURCES += mbsalign.c mbsalign.h
|
||||
|
||||
Include:
|
||||
"mbsalign.h"
|
||||
|
||||
License:
|
||||
LGPL
|
||||
|
||||
Maintainer:
|
||||
Pádraig Brady
|
||||
@@ -1,11 +0,0 @@
|
||||
Files:
|
||||
tests/test-mbsalign.c
|
||||
tests/macros.h
|
||||
|
||||
Depends-on:
|
||||
|
||||
configure.ac:
|
||||
|
||||
Makefile.am:
|
||||
TESTS += test-mbsalign
|
||||
check_PROGRAMS += test-mbsalign
|
||||
@@ -1,147 +0,0 @@
|
||||
/* Test that mbsalign works as advertised.
|
||||
Copyright (C) 2010-2023 Free Software Foundation, Inc.
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
||||
|
||||
/* Written by Pádraig Brady. */
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include "mbsalign.h"
|
||||
#include "macros.h"
|
||||
#include <stdlib.h>
|
||||
#include <locale.h>
|
||||
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
char dest[4 * 16 + 1];
|
||||
size_t width, n;
|
||||
|
||||
#ifdef __ANDROID__
|
||||
/* On Android ≥ 5.0, the default locale is the "C.UTF-8" locale, not the
|
||||
"C" locale. Furthermore, when you attempt to set the "C" or "POSIX"
|
||||
locale via setlocale(), what you get is a "C" locale with UTF-8 encoding,
|
||||
that is, effectively the "C.UTF-8" locale. */
|
||||
if (MB_CUR_MAX == 1)
|
||||
#endif
|
||||
{
|
||||
/* Test unibyte truncation. */
|
||||
width = 4;
|
||||
n = mbsalign ("t\tés", dest, sizeof dest, &width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == 4);
|
||||
}
|
||||
|
||||
/* Test center alignment. */
|
||||
width = 4;
|
||||
n = mbsalign ("es", dest, sizeof dest, &width, MBS_ALIGN_CENTER, 0);
|
||||
ASSERT (*dest == ' ' && *(dest + n - 1) == ' ');
|
||||
ASSERT (n == 4);
|
||||
|
||||
/* Test center alignment, with no trailing padding. */
|
||||
width = 4;
|
||||
n = mbsalign ("es", dest, sizeof dest, &width, MBS_ALIGN_CENTER,
|
||||
MBA_NO_RIGHT_PAD);
|
||||
ASSERT (n == 3);
|
||||
ASSERT (*dest == ' ' && *(dest + n - 1) == 's');
|
||||
|
||||
/* Test left alignment, with no trailing padding. (truncate only). */
|
||||
width = 4;
|
||||
n = mbsalign ("es", dest, sizeof dest, &width, MBS_ALIGN_LEFT,
|
||||
MBA_NO_RIGHT_PAD);
|
||||
ASSERT (n == 2);
|
||||
ASSERT (*dest == 'e' && *(dest + n - 1) == 's');
|
||||
|
||||
/* Test center alignment, with no padding. (truncate only). */
|
||||
width = 4;
|
||||
n = mbsalign ("es", dest, sizeof dest, &width, MBS_ALIGN_CENTER,
|
||||
MBA_NO_LEFT_PAD | MBA_NO_RIGHT_PAD);
|
||||
ASSERT (n == 2);
|
||||
ASSERT (*dest == 'e' && *(dest + n - 1) == 's');
|
||||
|
||||
/* Test center alignment, with no left padding. (may be useful for RTL?) */
|
||||
width = 4;
|
||||
n = mbsalign ("es", dest, sizeof dest, &width, MBS_ALIGN_CENTER,
|
||||
MBA_NO_LEFT_PAD);
|
||||
ASSERT (n == 3);
|
||||
ASSERT (*dest == 'e' && *(dest + n - 1) == ' ');
|
||||
|
||||
if (setlocale (LC_ALL, "en_US.UTF8"))
|
||||
{
|
||||
/* Check invalid input is flagged. */
|
||||
width = 4;
|
||||
n = mbsalign ("t\xe1\xe2s", dest, sizeof dest, &width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == (size_t) -1);
|
||||
|
||||
/* Check invalid input is treated as unibyte */
|
||||
width = 4;
|
||||
n = mbsalign ("t\xe1\xe2s", dest, sizeof dest, &width,
|
||||
MBS_ALIGN_LEFT, MBA_UNIBYTE_FALLBACK);
|
||||
ASSERT (n == 4);
|
||||
|
||||
/* Test multibyte center alignment. */
|
||||
width = 4;
|
||||
n = mbsalign ("és", dest, sizeof dest, &width, MBS_ALIGN_CENTER, 0);
|
||||
ASSERT (n == 5);
|
||||
ASSERT (*dest == ' ' && *(dest + n - 1) == ' ');
|
||||
|
||||
/* Test multibyte left alignment. */
|
||||
width = 4;
|
||||
n = mbsalign ("és", dest, sizeof dest, &width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == 5);
|
||||
ASSERT (*(dest + n - 1) == ' ' && *(dest + n - 2) == ' ');
|
||||
|
||||
/* Test multibyte right alignment. */
|
||||
width = 4;
|
||||
n = mbsalign ("és", dest, sizeof dest, &width, MBS_ALIGN_RIGHT, 0);
|
||||
ASSERT (n == 5);
|
||||
ASSERT (*(dest) == ' ' && *(dest + 1) == ' ');
|
||||
|
||||
/* multibyte multicell truncation. */
|
||||
width = 4; /* cells */
|
||||
n = mbsalign ("日月火水", dest, sizeof dest, &width,
|
||||
MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == 6); /* 2 characters */
|
||||
|
||||
/* multibyte unicell truncation. */
|
||||
width = 3; /* cells */
|
||||
n = mbsalign ("¹²³⁴", dest, sizeof dest, &width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == 6); /* 3 characters */
|
||||
|
||||
/* Check independence from dest buffer. */
|
||||
width = 4; /* cells */
|
||||
n = mbsalign ("¹²³⁴", dest, 0, &width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == 9); /* 4 characters */
|
||||
|
||||
/* Check that width is updated with cells required before padding. */
|
||||
width = 4; /* cells */
|
||||
n = mbsalign ("¹²³", dest, 0, &width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (width == 3);
|
||||
|
||||
/* Test case where output is larger than input
|
||||
(as tab converted to multi byte replacement char). */
|
||||
width = 4;
|
||||
n = mbsalign ("t\tés" /* 6 including NUL */ , dest, sizeof dest,
|
||||
&width, MBS_ALIGN_LEFT, 0);
|
||||
ASSERT (n == 7);
|
||||
|
||||
/* Test forced unibyte truncation. */
|
||||
width = 4;
|
||||
n = mbsalign ("t\tés", dest, sizeof dest, &width, MBS_ALIGN_LEFT,
|
||||
MBA_UNIBYTE_ONLY);
|
||||
ASSERT (n == 4);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -31,7 +31,6 @@
|
||||
#include "canonicalize.h"
|
||||
#include "fsusage.h"
|
||||
#include "human.h"
|
||||
#include "mbsalign.h"
|
||||
#include "mbswidth.h"
|
||||
#include "mountlist.h"
|
||||
#include "quote.h"
|
||||
@@ -169,48 +168,48 @@ struct field_data_t
|
||||
char const *arg;
|
||||
field_type_t field_type;
|
||||
char const *caption;/* nullptr means use default header of this field. */
|
||||
size_t width; /* Auto adjusted (up) widths used to align columns. */
|
||||
mbs_align_t align; /* Alignment for this field. */
|
||||
int width; /* Auto adjusted (up) widths used to align columns. */
|
||||
bool align_right; /* Whether to right-align columns, not left-align. */
|
||||
bool used;
|
||||
};
|
||||
|
||||
/* Header strings, minimum width and alignment for the above fields. */
|
||||
static struct field_data_t field_data[] = {
|
||||
[SOURCE_FIELD] = { SOURCE_FIELD,
|
||||
"source", OTHER_FLD, N_("Filesystem"), 14, MBS_ALIGN_LEFT, false },
|
||||
"source", OTHER_FLD, N_("Filesystem"), 14, false, false },
|
||||
|
||||
[FSTYPE_FIELD] = { FSTYPE_FIELD,
|
||||
"fstype", OTHER_FLD, N_("Type"), 4, MBS_ALIGN_LEFT, false },
|
||||
"fstype", OTHER_FLD, N_("Type"), 4, false, false },
|
||||
|
||||
[SIZE_FIELD] = { SIZE_FIELD,
|
||||
"size", BLOCK_FLD, N_("blocks"), 5, MBS_ALIGN_RIGHT, false },
|
||||
"size", BLOCK_FLD, N_("blocks"), 5, true, false },
|
||||
|
||||
[USED_FIELD] = { USED_FIELD,
|
||||
"used", BLOCK_FLD, N_("Used"), 5, MBS_ALIGN_RIGHT, false },
|
||||
"used", BLOCK_FLD, N_("Used"), 5, true, false },
|
||||
|
||||
[AVAIL_FIELD] = { AVAIL_FIELD,
|
||||
"avail", BLOCK_FLD, N_("Available"), 5, MBS_ALIGN_RIGHT, false },
|
||||
"avail", BLOCK_FLD, N_("Available"), 5, true, false },
|
||||
|
||||
[PCENT_FIELD] = { PCENT_FIELD,
|
||||
"pcent", BLOCK_FLD, N_("Use%"), 4, MBS_ALIGN_RIGHT, false },
|
||||
"pcent", BLOCK_FLD, N_("Use%"), 4, true, false },
|
||||
|
||||
[ITOTAL_FIELD] = { ITOTAL_FIELD,
|
||||
"itotal", INODE_FLD, N_("Inodes"), 5, MBS_ALIGN_RIGHT, false },
|
||||
"itotal", INODE_FLD, N_("Inodes"), 5, true, false },
|
||||
|
||||
[IUSED_FIELD] = { IUSED_FIELD,
|
||||
"iused", INODE_FLD, N_("IUsed"), 5, MBS_ALIGN_RIGHT, false },
|
||||
"iused", INODE_FLD, N_("IUsed"), 5, true, false },
|
||||
|
||||
[IAVAIL_FIELD] = { IAVAIL_FIELD,
|
||||
"iavail", INODE_FLD, N_("IFree"), 5, MBS_ALIGN_RIGHT, false },
|
||||
"iavail", INODE_FLD, N_("IFree"), 5, true, false },
|
||||
|
||||
[IPCENT_FIELD] = { IPCENT_FIELD,
|
||||
"ipcent", INODE_FLD, N_("IUse%"), 4, MBS_ALIGN_RIGHT, false },
|
||||
"ipcent", INODE_FLD, N_("IUse%"), 4, true, false },
|
||||
|
||||
[TARGET_FIELD] = { TARGET_FIELD,
|
||||
"target", OTHER_FLD, N_("Mounted on"), 0, MBS_ALIGN_LEFT, false },
|
||||
"target", OTHER_FLD, N_("Mounted on"), 0, false, false },
|
||||
|
||||
[FILE_FIELD] = { FILE_FIELD,
|
||||
"file", OTHER_FLD, N_("File"), 0, MBS_ALIGN_LEFT, false }
|
||||
"file", OTHER_FLD, N_("File"), 0, false, false }
|
||||
};
|
||||
|
||||
static char const *all_args_string =
|
||||
@@ -295,6 +294,8 @@ automount_stat_err (char const *file, struct stat *st)
|
||||
}
|
||||
}
|
||||
|
||||
enum { MBSWIDTH_FLAGS = MBSW_REJECT_INVALID | MBSW_REJECT_UNPRINTABLE };
|
||||
|
||||
/* Replace problematic chars with '?'.
|
||||
Since only control characters are currently considered,
|
||||
this should work in all encodings. */
|
||||
@@ -392,15 +393,15 @@ print_table (void)
|
||||
if (col != 0)
|
||||
putchar (' ');
|
||||
|
||||
int flags = 0;
|
||||
if (col == ncolumns - 1) /* The last one. */
|
||||
flags = MBA_NO_RIGHT_PAD;
|
||||
|
||||
size_t width = columns[col]->width;
|
||||
cell = ambsalign (cell, &width, columns[col]->align, flags);
|
||||
/* When ambsalign fails, output unaligned data. */
|
||||
fputs (cell ? cell : table[row][col], stdout);
|
||||
free (cell);
|
||||
int width = mbswidth (cell, MBSWIDTH_FLAGS);
|
||||
int fill = width < 0 ? 0 : columns[col]->width - width;
|
||||
if (columns[col]->align_right)
|
||||
for (; 0 < fill; fill--)
|
||||
putchar (' ');
|
||||
fputs (cell, stdout);
|
||||
if (col + 1 < ncolumns)
|
||||
for (; 0 < fill; fill--)
|
||||
putchar (' ');
|
||||
}
|
||||
putchar ('\n');
|
||||
}
|
||||
@@ -638,7 +639,7 @@ get_header (void)
|
||||
|
||||
table[nrows - 1][col] = cell;
|
||||
|
||||
size_t cell_width = mbswidth (cell, 0);
|
||||
int cell_width = mbswidth (cell, MBSWIDTH_FLAGS);
|
||||
columns[col]->width = MAX (columns[col]->width, cell_width);
|
||||
}
|
||||
}
|
||||
@@ -1252,7 +1253,7 @@ get_dev (char const *device, char const *mount_point, char const *file,
|
||||
affirm (cell);
|
||||
|
||||
replace_problematic_chars (cell);
|
||||
size_t cell_width = mbswidth (cell, 0);
|
||||
int cell_width = mbswidth (cell, MBSWIDTH_FLAGS);
|
||||
columns[col]->width = MAX (columns[col]->width, cell_width);
|
||||
table[nrows - 1][col] = cell;
|
||||
}
|
||||
|
||||
@@ -108,7 +108,6 @@
|
||||
#include "xstrtol.h"
|
||||
#include "xstrtol-error.h"
|
||||
#include "areadlink.h"
|
||||
#include "mbsalign.h"
|
||||
#include "dircolors.h"
|
||||
#include "xgethostname.h"
|
||||
#include "c-ctype.h"
|
||||
@@ -1282,6 +1281,8 @@ file_escape_init (void)
|
||||
RFC3986[i] |= c_isalnum (i) || i == '~' || i == '-' || i == '.' || i == '_';
|
||||
}
|
||||
|
||||
enum { MBSWIDTH_FLAGS = MBSW_REJECT_INVALID | MBSW_REJECT_UNPRINTABLE };
|
||||
|
||||
/* Read the abbreviated month names from the locale, to align them
|
||||
and to determine the max width of the field and to truncate names
|
||||
greater than our max allowed.
|
||||
@@ -1290,11 +1291,6 @@ file_escape_init (void)
|
||||
variable width abbreviated months and also precomputing/caching
|
||||
the names was seen to increase the performance of ls significantly. */
|
||||
|
||||
/* max number of display cells to use.
|
||||
As of 2018 the abmon for Arabic has entries with width 12.
|
||||
It doesn't make much sense to support wider than this
|
||||
and locales should aim for abmon entries of width <= 5. */
|
||||
enum { MAX_MON_WIDTH = 12 };
|
||||
/* abformat[RECENT][MON] is the format to use for timestamps with
|
||||
recentness RECENT and month MON. */
|
||||
enum { ABFORMAT_SIZE = 128 };
|
||||
@@ -1313,28 +1309,41 @@ abmon_init (char abmon[12][ABFORMAT_SIZE])
|
||||
#ifndef HAVE_NL_LANGINFO
|
||||
return false;
|
||||
#else
|
||||
size_t required_mon_width = MAX_MON_WIDTH;
|
||||
size_t curr_max_width;
|
||||
do
|
||||
int max_mon_width = 0;
|
||||
int mon_width[12];
|
||||
int mon_len[12];
|
||||
|
||||
for (int i = 0; i < 12; i++)
|
||||
{
|
||||
curr_max_width = required_mon_width;
|
||||
required_mon_width = 0;
|
||||
for (int i = 0; i < 12; i++)
|
||||
char const *abbr = nl_langinfo (ABMON_1 + i);
|
||||
mon_len[i] = strnlen (abbr, ABFORMAT_SIZE);
|
||||
if (mon_len[i] == ABFORMAT_SIZE)
|
||||
return false;
|
||||
if (strchr (abbr, '%'))
|
||||
return false;
|
||||
mon_width[i] = mbswidth (strcpy (abmon[i], abbr), MBSWIDTH_FLAGS);
|
||||
if (mon_width[i] < 0)
|
||||
return false;
|
||||
max_mon_width = MAX (max_mon_width, mon_width[i]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < 12; i++)
|
||||
{
|
||||
int fill = max_mon_width - mon_width[i];
|
||||
if (ABFORMAT_SIZE - mon_len[i] <= fill)
|
||||
return false;
|
||||
bool align_left = !isdigit (to_uchar (abmon[i][0]));
|
||||
int fill_offset;
|
||||
if (align_left)
|
||||
fill_offset = mon_len[i];
|
||||
else
|
||||
{
|
||||
size_t width = curr_max_width;
|
||||
char const *abbr = nl_langinfo (ABMON_1 + i);
|
||||
if (strchr (abbr, '%'))
|
||||
return false;
|
||||
mbs_align_t alignment = isdigit (to_uchar (*abbr))
|
||||
? MBS_ALIGN_RIGHT : MBS_ALIGN_LEFT;
|
||||
size_t req = mbsalign (abbr, abmon[i], ABFORMAT_SIZE,
|
||||
&width, alignment, 0);
|
||||
if (! (req < ABFORMAT_SIZE))
|
||||
return false;
|
||||
required_mon_width = MAX (required_mon_width, width);
|
||||
memmove (abmon[i] + fill, abmon[i], mon_len[i]);
|
||||
fill_offset = 0;
|
||||
}
|
||||
memset (abmon[i] + fill_offset, ' ', fill);
|
||||
abmon[i][mon_len[i] + fill] = '\0';
|
||||
}
|
||||
while (curr_max_width > required_mon_width);
|
||||
|
||||
return true;
|
||||
#endif
|
||||
@@ -3607,7 +3616,7 @@ gobble_file (char const *name, enum filetype type, ino_t inode,
|
||||
char buf[LONGEST_HUMAN_READABLE + 1];
|
||||
int len = mbswidth (human_readable (blocks, buf, human_output_opts,
|
||||
ST_NBLOCKSIZE, output_block_size),
|
||||
0);
|
||||
MBSWIDTH_FLAGS);
|
||||
if (block_size_width < len)
|
||||
block_size_width = len;
|
||||
}
|
||||
@@ -3670,7 +3679,7 @@ gobble_file (char const *name, enum filetype type, ino_t inode,
|
||||
int len = mbswidth (human_readable (size, buf,
|
||||
file_human_output_opts,
|
||||
1, file_output_block_size),
|
||||
0);
|
||||
MBSWIDTH_FLAGS);
|
||||
if (file_size_width < len)
|
||||
file_size_width = len;
|
||||
}
|
||||
@@ -4208,7 +4217,7 @@ long_time_expected_width (void)
|
||||
size_t len = align_nstrftime (buf, sizeof buf, false,
|
||||
&tm, localtz, 0);
|
||||
if (len != 0)
|
||||
width = mbsnwidth (buf, len, 0);
|
||||
width = mbsnwidth (buf, len, MBSWIDTH_FLAGS);
|
||||
}
|
||||
|
||||
if (width < 0)
|
||||
@@ -4226,7 +4235,8 @@ format_user_or_group (char const *name, uintmax_t id, int width)
|
||||
{
|
||||
if (name)
|
||||
{
|
||||
int width_gap = width - mbswidth (name, 0);
|
||||
int name_width = mbswidth (name, MBSWIDTH_FLAGS);
|
||||
int width_gap = name_width < 0 ? 0 : width - name_width;
|
||||
int pad = MAX (0, width_gap);
|
||||
dired_outstring (name);
|
||||
|
||||
@@ -4257,21 +4267,19 @@ format_group (gid_t g, int width, bool stat_ok)
|
||||
(numeric_ids ? nullptr : getgroup (g)), g, width);
|
||||
}
|
||||
|
||||
/* Return the number of columns that format_user_or_group will print. */
|
||||
/* Return the number of columns that format_user_or_group will print,
|
||||
or -1 if unknown. */
|
||||
|
||||
static int
|
||||
format_user_or_group_width (char const *name, uintmax_t id)
|
||||
{
|
||||
if (name)
|
||||
{
|
||||
int len = mbswidth (name, 0);
|
||||
return MAX (0, len);
|
||||
}
|
||||
else
|
||||
return snprintf (nullptr, 0, "%"PRIuMAX, id);
|
||||
return (name
|
||||
? mbswidth (name, MBSWIDTH_FLAGS)
|
||||
: snprintf (nullptr, 0, "%"PRIuMAX, id));
|
||||
}
|
||||
|
||||
/* Return the number of columns that format_user will print. */
|
||||
/* Return the number of columns that format_user will print,
|
||||
or -1 if unknown. */
|
||||
|
||||
static int
|
||||
format_user_width (uid_t u)
|
||||
@@ -4372,8 +4380,9 @@ print_long_format (const struct fileinfo *f)
|
||||
? "?"
|
||||
: human_readable (ST_NBLOCKS (f->stat), hbuf, human_output_opts,
|
||||
ST_NBLOCKSIZE, output_block_size));
|
||||
int pad;
|
||||
for (pad = block_size_width - mbswidth (blocks, 0); 0 < pad; pad--)
|
||||
int blocks_width = mbswidth (blocks, MBSWIDTH_FLAGS);
|
||||
for (int pad = blocks_width < 0 ? 0 : block_size_width - blocks_width;
|
||||
0 < pad; pad--)
|
||||
*p++ = ' ';
|
||||
while ((*p++ = *blocks++))
|
||||
continue;
|
||||
@@ -4432,8 +4441,9 @@ print_long_format (const struct fileinfo *f)
|
||||
: human_readable (unsigned_file_size (f->stat.st_size),
|
||||
hbuf, file_human_output_opts, 1,
|
||||
file_output_block_size));
|
||||
int pad;
|
||||
for (pad = file_size_width - mbswidth (size, 0); 0 < pad; pad--)
|
||||
int size_width = mbswidth (size, MBSWIDTH_FLAGS);
|
||||
for (int pad = size_width < 0 ? 0 : block_size_width - size_width;
|
||||
0 < pad; pad--)
|
||||
*p++ = ' ';
|
||||
while ((*p++ = *size++))
|
||||
continue;
|
||||
@@ -4677,7 +4687,10 @@ quote_name_buf (char **inbuf, size_t bufsize, char *name,
|
||||
else if (width != nullptr)
|
||||
{
|
||||
if (MB_CUR_MAX > 1)
|
||||
displayed_width = mbsnwidth (buf, len, 0);
|
||||
{
|
||||
displayed_width = mbsnwidth (buf, len, MBSWIDTH_FLAGS);
|
||||
displayed_width = MAX (0, displayed_width);
|
||||
}
|
||||
else
|
||||
{
|
||||
char const *p = buf;
|
||||
|
||||
+86
-108
@@ -17,13 +17,14 @@
|
||||
#include <config.h>
|
||||
#include <float.h>
|
||||
#include <getopt.h>
|
||||
#include <stdckdint.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/types.h>
|
||||
#include <langinfo.h>
|
||||
|
||||
#include "mbsalign.h"
|
||||
#include "argmatch.h"
|
||||
#include "c-ctype.h"
|
||||
#include "mbswidth.h"
|
||||
#include "quote.h"
|
||||
#include "system.h"
|
||||
#include "xstrtol.h"
|
||||
@@ -173,9 +174,9 @@ static uintmax_t from_unit_size = 1;
|
||||
static uintmax_t to_unit_size = 1;
|
||||
static int grouping = 0;
|
||||
static char *padding_buffer = nullptr;
|
||||
static size_t padding_buffer_size = 0;
|
||||
static long int padding_width = 0;
|
||||
static long int zero_padding_width = 0;
|
||||
static idx_t padding_buffer_size = 0;
|
||||
static intmax_t padding_width = 0;
|
||||
static int zero_padding_width = 0;
|
||||
static long int user_precision = -1;
|
||||
static char const *format_str = nullptr;
|
||||
static char *format_str_prefix = nullptr;
|
||||
@@ -187,7 +188,6 @@ static int conv_exit_code = EXIT_CONVERSION_WARNINGS;
|
||||
|
||||
/* auto-pad each line based on skipped whitespace. */
|
||||
static int auto_padding = 0;
|
||||
static mbs_align_t padding_alignment = MBS_ALIGN_RIGHT;
|
||||
|
||||
/* field delimiter */
|
||||
static int delimiter = DELIMITER_DEFAULT;
|
||||
@@ -728,19 +728,17 @@ simple_strtod_fatal (enum simple_strtod_error err, char const *input_str)
|
||||
error (conv_exit_code, 0, gettext (msgid), quote (input_str));
|
||||
}
|
||||
|
||||
/* Convert VAL to a human format string in BUF. */
|
||||
static void
|
||||
/* Convert VAL to a human format string using PRECISION in BUF of size
|
||||
BUF_SIZE. Use SCALE, GROUP, and ROUND to format. Return
|
||||
the number of bytes needed to represent VAL. If this number is not
|
||||
less than BUF_SIZE, the buffer is too small; if it is negative, the
|
||||
formatting failed for some reason. */
|
||||
static int
|
||||
double_to_human (long double val, int precision,
|
||||
char *buf, size_t buf_size,
|
||||
char *buf, idx_t buf_size,
|
||||
enum scale_type scale, int group, enum round_type round)
|
||||
{
|
||||
int num_size;
|
||||
char fmt[64];
|
||||
static_assert ((INT_BUFSIZE_BOUND (zero_padding_width)
|
||||
+ INT_BUFSIZE_BOUND (precision)
|
||||
+ 10 /* for %.Lf etc. */)
|
||||
< sizeof fmt);
|
||||
|
||||
char fmt[sizeof "%'0.*Lfi%s%s%s" + INT_STRLEN_BOUND (zero_padding_width)];
|
||||
char *pfmt = fmt;
|
||||
*pfmt++ = '%';
|
||||
|
||||
@@ -748,7 +746,7 @@ double_to_human (long double val, int precision,
|
||||
*pfmt++ = '\'';
|
||||
|
||||
if (zero_padding_width)
|
||||
pfmt += snprintf (pfmt, sizeof (fmt) - 2, "0%ld", zero_padding_width);
|
||||
pfmt += sprintf (pfmt, "0%d", zero_padding_width);
|
||||
|
||||
devmsg ("double_to_human:\n");
|
||||
|
||||
@@ -762,13 +760,10 @@ double_to_human (long double val, int precision,
|
||||
" no scaling, returning (grouped) value: %'.*Lf\n" :
|
||||
" no scaling, returning value: %.*Lf\n", precision, val);
|
||||
|
||||
stpcpy (pfmt, ".*Lf");
|
||||
strcpy (pfmt, ".*Lf%s");
|
||||
|
||||
num_size = snprintf (buf, buf_size, fmt, precision, val);
|
||||
if (num_size < 0 || num_size >= (int) buf_size)
|
||||
error (EXIT_FAILURE, 0,
|
||||
_("failed to prepare value '%Lf' for printing"), val);
|
||||
return;
|
||||
return snprintf (buf, buf_size, fmt, precision, val,
|
||||
suffix ? suffix : "");
|
||||
}
|
||||
|
||||
/* Scaling requested by user. */
|
||||
@@ -810,23 +805,14 @@ double_to_human (long double val, int precision,
|
||||
|
||||
devmsg (" after rounding, value=%Lf * %0.f ^ %d\n", val, scale_base, power);
|
||||
|
||||
stpcpy (pfmt, ".*Lf%s");
|
||||
strcpy (pfmt, ".*Lf%s%s%s");
|
||||
|
||||
int prec = user_precision == -1 ? show_decimal_point : user_precision;
|
||||
|
||||
/* buf_size - 1 used here to ensure place for possible scale_IEC_I suffix. */
|
||||
num_size = snprintf (buf, buf_size - 1, fmt, prec, val,
|
||||
suffix_power_char (power));
|
||||
if (num_size < 0 || num_size >= (int) buf_size - 1)
|
||||
error (EXIT_FAILURE, 0,
|
||||
_("failed to prepare value '%Lf' for printing"), val);
|
||||
|
||||
if (scale == scale_IEC_I && power > 0)
|
||||
strncat (buf, "i", buf_size - num_size - 1);
|
||||
|
||||
devmsg (" returning value: %s\n", quote (buf));
|
||||
|
||||
return;
|
||||
return snprintf (buf, buf_size, fmt, prec, val,
|
||||
suffix_power_char (power),
|
||||
&"i"[! (scale == scale_IEC_I && 0 < power)],
|
||||
suffix ? suffix : "");
|
||||
}
|
||||
|
||||
/* Convert a string of decimal digits, N_STRING, with an optional suffix
|
||||
@@ -876,17 +862,6 @@ unit_to_umax (char const *n_string)
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
setup_padding_buffer (size_t min_size)
|
||||
{
|
||||
if (padding_buffer_size > min_size)
|
||||
return;
|
||||
|
||||
padding_buffer_size = min_size + 1;
|
||||
padding_buffer = xrealloc (padding_buffer, padding_buffer_size);
|
||||
}
|
||||
|
||||
void
|
||||
usage (int status)
|
||||
{
|
||||
@@ -1052,7 +1027,7 @@ Examples:\n\
|
||||
|
||||
NOTES:
|
||||
1. This function sets the global variables:
|
||||
padding_width, padding_alignment, grouping,
|
||||
padding_width, grouping,
|
||||
format_str_prefix, format_str_suffix
|
||||
2. The function aborts on any errors. */
|
||||
static void
|
||||
@@ -1061,7 +1036,6 @@ parse_format_string (char const *fmt)
|
||||
size_t i;
|
||||
size_t prefix_len = 0;
|
||||
size_t suffix_pos;
|
||||
long int pad = 0;
|
||||
char *endptr = nullptr;
|
||||
bool zero_padding = false;
|
||||
|
||||
@@ -1092,30 +1066,25 @@ parse_format_string (char const *fmt)
|
||||
break;
|
||||
}
|
||||
|
||||
errno = 0;
|
||||
pad = strtol (fmt + i, &endptr, 10);
|
||||
if (errno == ERANGE || pad < -LONG_MAX)
|
||||
error (EXIT_FAILURE, 0,
|
||||
_("invalid format %s (width overflow)"), quote (fmt));
|
||||
intmax_t pad = strtoimax (fmt + i, &endptr, 10);
|
||||
|
||||
if (endptr != (fmt + i) && pad != 0)
|
||||
if (pad != 0)
|
||||
{
|
||||
if (debug && padding_width && !(zero_padding && pad > 0))
|
||||
error (0, 0, _("--format padding overriding --padding"));
|
||||
|
||||
/* Set padding width and alignment. On overflow, set widths to
|
||||
large values that cause later code to avoid undefined behavior
|
||||
and fail at a reasonable point. */
|
||||
if (pad < 0)
|
||||
{
|
||||
padding_alignment = MBS_ALIGN_LEFT;
|
||||
padding_width = -pad;
|
||||
}
|
||||
padding_width = pad;
|
||||
else
|
||||
{
|
||||
if (zero_padding)
|
||||
zero_padding_width = pad;
|
||||
zero_padding_width = MIN (pad, INT_MAX);
|
||||
else
|
||||
padding_width = pad;
|
||||
}
|
||||
|
||||
}
|
||||
i = endptr - fmt;
|
||||
|
||||
@@ -1159,11 +1128,10 @@ parse_format_string (char const *fmt)
|
||||
format_str_suffix = xstrdup (fmt + suffix_pos);
|
||||
|
||||
devmsg ("format String:\n input: %s\n grouping: %s\n"
|
||||
" padding width: %ld\n alignment: %s\n"
|
||||
" padding width: %jd\n"
|
||||
" prefix: %s\n suffix: %s\n",
|
||||
quote_n (0, fmt), (grouping) ? "yes" : "no",
|
||||
padding_width,
|
||||
(padding_alignment == MBS_ALIGN_LEFT) ? "Left" : "Right",
|
||||
quote_n (1, format_str_prefix ? format_str_prefix : ""),
|
||||
quote_n (2, format_str_suffix ? format_str_suffix : ""));
|
||||
}
|
||||
@@ -1203,12 +1171,11 @@ parse_human_number (char const *str, long double /*output */ *value,
|
||||
|
||||
/* Print the given VAL, using the requested representation.
|
||||
The number is printed to STDOUT, with padding and alignment. */
|
||||
static int
|
||||
prepare_padded_number (const long double val, size_t precision)
|
||||
static bool
|
||||
prepare_padded_number (const long double val, size_t precision,
|
||||
intmax_t *padding)
|
||||
{
|
||||
/* Generate Output. */
|
||||
char buf[128];
|
||||
|
||||
size_t precision_used = user_precision == -1 ? precision : user_precision;
|
||||
|
||||
/* Can't reliably print too-large values without auto-scaling. */
|
||||
@@ -1229,7 +1196,7 @@ prepare_padded_number (const long double val, size_t precision)
|
||||
_("value too large to be printed: '%Lg'"
|
||||
" (consider using --to)"), val);
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (x > MAX_ACCEPTABLE_DIGITS - 1)
|
||||
@@ -1237,42 +1204,65 @@ prepare_padded_number (const long double val, size_t precision)
|
||||
if (inval_style != inval_ignore)
|
||||
error (conv_exit_code, 0, _("value too large to be printed: '%Lg'"
|
||||
" (cannot handle values > 999Q)"), val);
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
double_to_human (val, precision_used, buf, sizeof (buf),
|
||||
scale_to, grouping, round_style);
|
||||
if (suffix)
|
||||
strncat (buf, suffix, sizeof (buf) - strlen (buf) -1);
|
||||
while (true)
|
||||
{
|
||||
int numlen = double_to_human (val, precision_used,
|
||||
padding_buffer, padding_buffer_size,
|
||||
scale_to, grouping, round_style);
|
||||
ptrdiff_t growth;
|
||||
if (numlen < 0 || ckd_sub (&growth, numlen, padding_buffer_size - 1))
|
||||
error (EXIT_FAILURE, 0,
|
||||
_("failed to prepare value '%Lf' for printing"), val);
|
||||
if (growth <= 0)
|
||||
break;
|
||||
padding_buffer = xpalloc (padding_buffer, &padding_buffer_size,
|
||||
growth, -1, 1);
|
||||
}
|
||||
|
||||
devmsg ("formatting output:\n value: %Lf\n humanized: %s\n",
|
||||
val, quote (buf));
|
||||
val, quote (padding_buffer));
|
||||
|
||||
if (padding_width && strlen (buf) < padding_width)
|
||||
intmax_t pad = 0;
|
||||
if (padding_width)
|
||||
{
|
||||
size_t w = padding_width;
|
||||
mbsalign (buf, padding_buffer, padding_buffer_size, &w,
|
||||
padding_alignment, MBA_UNIBYTE_ONLY);
|
||||
|
||||
devmsg (" After padding: %s\n", quote (padding_buffer));
|
||||
}
|
||||
else
|
||||
{
|
||||
setup_padding_buffer (strlen (buf) + 1);
|
||||
strcpy (padding_buffer, buf);
|
||||
int buf_width = mbswidth (padding_buffer,
|
||||
MBSW_REJECT_INVALID | MBSW_REJECT_UNPRINTABLE);
|
||||
if (0 <= buf_width)
|
||||
{
|
||||
if (padding_width < 0)
|
||||
{
|
||||
if (padding_width < -buf_width)
|
||||
pad = padding_width + buf_width;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (buf_width < padding_width)
|
||||
pad = padding_width - buf_width;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
*padding = pad;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void
|
||||
print_padded_number (void)
|
||||
print_padded_number (intmax_t padding)
|
||||
{
|
||||
if (format_str_prefix)
|
||||
fputs (format_str_prefix, stdout);
|
||||
|
||||
for (intmax_t p = padding; 0 < p; p--)
|
||||
putchar (' ');
|
||||
|
||||
fputs (padding_buffer, stdout);
|
||||
|
||||
for (intmax_t p = padding; p < 0; p++)
|
||||
putchar (' ');
|
||||
|
||||
if (format_str_suffix)
|
||||
fputs (format_str_suffix, stdout);
|
||||
}
|
||||
@@ -1305,16 +1295,8 @@ process_suffixed_number (char *text, long double *result,
|
||||
/* setup auto-padding. */
|
||||
if (auto_padding)
|
||||
{
|
||||
if (text < p || field > 1)
|
||||
{
|
||||
padding_width = strlen (text);
|
||||
setup_padding_buffer (padding_width);
|
||||
}
|
||||
else
|
||||
{
|
||||
padding_width = 0;
|
||||
}
|
||||
devmsg ("setting Auto-Padding to %ld characters\n", padding_width);
|
||||
padding_width = text < p || 1 < field ? strlen (text) : 0;
|
||||
devmsg ("setting Auto-Padding to %jd characters\n", padding_width);
|
||||
}
|
||||
|
||||
long double val = 0;
|
||||
@@ -1393,11 +1375,12 @@ process_field (char *text, uintmax_t field)
|
||||
valid_number =
|
||||
process_suffixed_number (text, &val, &precision, field);
|
||||
|
||||
intmax_t padding;
|
||||
if (valid_number)
|
||||
valid_number = prepare_padded_number (val, precision);
|
||||
valid_number = prepare_padded_number (val, precision, &padding);
|
||||
|
||||
if (valid_number)
|
||||
print_padded_number ();
|
||||
print_padded_number (padding);
|
||||
else
|
||||
fputs (text, stdout);
|
||||
}
|
||||
@@ -1508,15 +1491,12 @@ main (int argc, char **argv)
|
||||
break;
|
||||
|
||||
case PADDING_OPTION:
|
||||
if (xstrtol (optarg, nullptr, 10, &padding_width, "") != LONGINT_OK
|
||||
|| padding_width == 0 || padding_width < -LONG_MAX)
|
||||
if (((xstrtoimax (optarg, nullptr, 10, &padding_width, "")
|
||||
& ~LONGINT_OVERFLOW)
|
||||
!= LONGINT_OK)
|
||||
|| padding_width == 0)
|
||||
error (EXIT_FAILURE, 0, _("invalid padding value %s"),
|
||||
quote (optarg));
|
||||
if (padding_width < 0)
|
||||
{
|
||||
padding_alignment = MBS_ALIGN_LEFT;
|
||||
padding_width = -padding_width;
|
||||
}
|
||||
/* TODO: We probably want to apply a specific --padding
|
||||
to --header lines too. */
|
||||
break;
|
||||
@@ -1605,8 +1585,6 @@ main (int argc, char **argv)
|
||||
error (0, 0, _("grouping has no effect in this locale"));
|
||||
}
|
||||
|
||||
|
||||
setup_padding_buffer (padding_width);
|
||||
auto_padding = (padding_width == 0 && delimiter == DELIMITER_DEFAULT);
|
||||
|
||||
if (inval_style != inval_abort)
|
||||
|
||||
@@ -159,6 +159,9 @@ my @Tests =
|
||||
# space(s) between number and suffix. Note only field 1 is used
|
||||
# by default so specify the NUL delimiter to consider the whole "line".
|
||||
['suf-19', "-d '' --from=si '4.0 K'", {OUT => "4000"}],
|
||||
['suf-20',
|
||||
'--suffix=Fooxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy 0',
|
||||
{OUT => "0Fooxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy"}],
|
||||
|
||||
## GROUPING
|
||||
|
||||
@@ -178,9 +181,6 @@ my @Tests =
|
||||
['pad-3.1', '--padding=0 5',
|
||||
{ERR => "$prog: invalid padding value '0'\n"},
|
||||
{EXIT => '1'}],
|
||||
['pad-3.2', "--padding=$limits->{LONG_MIN} 0",
|
||||
{ERR => "$prog: invalid padding value '$limits->{LONG_MIN}'\n"},
|
||||
{EXIT => '1'}],
|
||||
['pad-4', '--padding=10 --to=si 50000', {OUT=>' 50K'}],
|
||||
['pad-5', '--padding=-10 --to=si 50000', {OUT=>'50K '}],
|
||||
|
||||
@@ -675,10 +675,6 @@ my @Tests =
|
||||
['fmt-err-6', '--format "%f %f"',
|
||||
{ERR=>"$prog: format '%f %f' has too many % directives\n"},
|
||||
{EXIT=>1}],
|
||||
['fmt-err-7', '--format "%'.$limits->{LONG_OFLOW}.'f"',
|
||||
{ERR=>"$prog: invalid format '%$limits->{LONG_OFLOW}f'".
|
||||
" (width overflow)\n"},
|
||||
{EXIT=>1}],
|
||||
['fmt-err-9', '--format "%f" --grouping',
|
||||
{ERR=>"$prog: --grouping cannot be combined with --format\n"},
|
||||
{EXIT=>1}],
|
||||
|
||||
Reference in new issue
Block a user