Changeset View
Changeset View
Standalone View
Standalone View
usr.bin/sort/bwstring.c
Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines | |||||
initialise_months(void) | initialise_months(void) | ||||
{ | { | ||||
const nl_item item[12] = { ABMON_1, ABMON_2, ABMON_3, ABMON_4, | const nl_item item[12] = { ABMON_1, ABMON_2, ABMON_3, ABMON_4, | ||||
ABMON_5, ABMON_6, ABMON_7, ABMON_8, ABMON_9, ABMON_10, | ABMON_5, ABMON_6, ABMON_7, ABMON_8, ABMON_9, ABMON_10, | ||||
ABMON_11, ABMON_12 }; | ABMON_11, ABMON_12 }; | ||||
char *tmp; | char *tmp; | ||||
size_t len; | size_t len; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
if (cmonths == NULL) { | if (cmonths == NULL) { | ||||
char *m; | char *m; | ||||
cmonths = sort_malloc(sizeof(char*) * 12); | cmonths = sort_malloc(sizeof(char*) * 12); | ||||
for (int i = 0; i < 12; i++) { | for (int i = 0; i < 12; i++) { | ||||
cmonths[i] = NULL; | cmonths[i] = NULL; | ||||
tmp = nl_langinfo(item[i]); | tmp = nl_langinfo(item[i]); | ||||
if (debug_sort) | if (debug_sort) | ||||
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines | |||||
} | } | ||||
/* counterparts of wcs functions */ | /* counterparts of wcs functions */ | ||||
void | void | ||||
bwsprintf(FILE *f, struct bwstring *bws, const char *prefix, const char *suffix) | bwsprintf(FILE *f, struct bwstring *bws, const char *prefix, const char *suffix) | ||||
{ | { | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
fprintf(f, "%s%s%s", prefix, bws->data.cstr, suffix); | fprintf(f, "%s%s%s", prefix, bws->data.cstr, suffix); | ||||
else | else | ||||
fprintf(f, "%s%S%s", prefix, bws->data.wstr, suffix); | fprintf(f, "%s%S%s", prefix, bws->data.wstr, suffix); | ||||
} | } | ||||
const void* bwsrawdata(const struct bwstring *bws) | const void* bwsrawdata(const struct bwstring *bws) | ||||
{ | { | ||||
return (&(bws->data)); | return (&(bws->data)); | ||||
} | } | ||||
size_t bwsrawlen(const struct bwstring *bws) | size_t bwsrawlen(const struct bwstring *bws) | ||||
{ | { | ||||
return ((MB_CUR_MAX == 1) ? bws->len : SIZEOF_WCHAR_STRING(bws->len)); | return ((mb_cur_max == 1) ? bws->len : SIZEOF_WCHAR_STRING(bws->len)); | ||||
} | } | ||||
size_t | size_t | ||||
bws_memsize(const struct bwstring *bws) | bws_memsize(const struct bwstring *bws) | ||||
{ | { | ||||
return ((MB_CUR_MAX == 1) ? (bws->len + 2 + sizeof(struct bwstring)) : | return ((mb_cur_max == 1) ? (bws->len + 2 + sizeof(struct bwstring)) : | ||||
(SIZEOF_WCHAR_STRING(bws->len + 1) + sizeof(struct bwstring))); | (SIZEOF_WCHAR_STRING(bws->len + 1) + sizeof(struct bwstring))); | ||||
} | } | ||||
void | void | ||||
bws_setlen(struct bwstring *bws, size_t newlen) | bws_setlen(struct bwstring *bws, size_t newlen) | ||||
{ | { | ||||
if (bws && newlen != bws->len && newlen <= bws->len) { | if (bws && newlen != bws->len && newlen <= bws->len) { | ||||
bws->len = newlen; | bws->len = newlen; | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
bws->data.cstr[newlen] = '\0'; | bws->data.cstr[newlen] = '\0'; | ||||
else | else | ||||
bws->data.wstr[newlen] = L'\0'; | bws->data.wstr[newlen] = L'\0'; | ||||
} | } | ||||
} | } | ||||
/* | /* | ||||
* Allocate a new binary string of specified size | * Allocate a new binary string of specified size | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
bwsalloc(size_t sz) | bwsalloc(size_t sz) | ||||
{ | { | ||||
struct bwstring *ret; | struct bwstring *ret; | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
ret = sort_malloc(sizeof(struct bwstring) + 1 + sz); | ret = sort_malloc(sizeof(struct bwstring) + 1 + sz); | ||||
else | else | ||||
ret = sort_malloc(sizeof(struct bwstring) + | ret = sort_malloc(sizeof(struct bwstring) + | ||||
SIZEOF_WCHAR_STRING(sz + 1)); | SIZEOF_WCHAR_STRING(sz + 1)); | ||||
ret->len = sz; | ret->len = sz; | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
ret->data.cstr[ret->len] = '\0'; | ret->data.cstr[ret->len] = '\0'; | ||||
else | else | ||||
ret->data.wstr[ret->len] = L'\0'; | ret->data.wstr[ret->len] = L'\0'; | ||||
return (ret); | return (ret); | ||||
} | } | ||||
/* | /* | ||||
* Create a copy of binary string. | * Create a copy of binary string. | ||||
* New string size equals the length of the old string. | * New string size equals the length of the old string. | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
bwsdup(const struct bwstring *s) | bwsdup(const struct bwstring *s) | ||||
{ | { | ||||
if (s == NULL) | if (s == NULL) | ||||
return (NULL); | return (NULL); | ||||
else { | else { | ||||
struct bwstring *ret = bwsalloc(s->len); | struct bwstring *ret = bwsalloc(s->len); | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
memcpy(ret->data.cstr, s->data.cstr, (s->len)); | memcpy(ret->data.cstr, s->data.cstr, (s->len)); | ||||
else | else | ||||
memcpy(ret->data.wstr, s->data.wstr, | memcpy(ret->data.wstr, s->data.wstr, | ||||
SIZEOF_WCHAR_STRING(s->len)); | SIZEOF_WCHAR_STRING(s->len)); | ||||
return (ret); | return (ret); | ||||
} | } | ||||
} | } | ||||
/* | /* | ||||
* Create a new binary string from a wide character buffer. | * Create a new binary string from a wide character buffer. | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
bwssbdup(const wchar_t *str, size_t len) | bwssbdup(const wchar_t *str, size_t len) | ||||
{ | { | ||||
if (str == NULL) | if (str == NULL) | ||||
return ((len == 0) ? bwsalloc(0) : NULL); | return ((len == 0) ? bwsalloc(0) : NULL); | ||||
else { | else { | ||||
struct bwstring *ret; | struct bwstring *ret; | ||||
ret = bwsalloc(len); | ret = bwsalloc(len); | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
for (size_t i = 0; i < len; ++i) | for (size_t i = 0; i < len; ++i) | ||||
ret->data.cstr[i] = (unsigned char) str[i]; | ret->data.cstr[i] = (unsigned char) str[i]; | ||||
else | else | ||||
memcpy(ret->data.wstr, str, SIZEOF_WCHAR_STRING(len)); | memcpy(ret->data.wstr, str, SIZEOF_WCHAR_STRING(len)); | ||||
return (ret); | return (ret); | ||||
} | } | ||||
} | } | ||||
/* | /* | ||||
* Create a new binary string from a raw binary buffer. | * Create a new binary string from a raw binary buffer. | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
bwscsbdup(const unsigned char *str, size_t len) | bwscsbdup(const unsigned char *str, size_t len) | ||||
{ | { | ||||
struct bwstring *ret; | struct bwstring *ret; | ||||
ret = bwsalloc(len); | ret = bwsalloc(len); | ||||
if (str) { | if (str) { | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
memcpy(ret->data.cstr, str, len); | memcpy(ret->data.cstr, str, len); | ||||
else { | else { | ||||
mbstate_t mbs; | mbstate_t mbs; | ||||
const char *s; | const char *s; | ||||
size_t charlen, chars, cptr; | size_t charlen, chars, cptr; | ||||
chars = 0; | chars = 0; | ||||
cptr = 0; | cptr = 0; | ||||
s = (const char *) str; | s = (const char *) str; | ||||
memset(&mbs, 0, sizeof(mbs)); | memset(&mbs, 0, sizeof(mbs)); | ||||
while (cptr < len) { | while (cptr < len) { | ||||
size_t n = MB_CUR_MAX; | size_t n = mb_cur_max; | ||||
if (n > len - cptr) | if (n > len - cptr) | ||||
n = len - cptr; | n = len - cptr; | ||||
charlen = mbrlen(s + cptr, n, &mbs); | charlen = mbrlen(s + cptr, n, &mbs); | ||||
switch (charlen) { | switch (charlen) { | ||||
case 0: | case 0: | ||||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||||
case (size_t) -1: | case (size_t) -1: | ||||
Show All 40 Lines | |||||
bwscpy(struct bwstring *dst, const struct bwstring *src) | bwscpy(struct bwstring *dst, const struct bwstring *src) | ||||
{ | { | ||||
size_t nums = src->len; | size_t nums = src->len; | ||||
if (nums > dst->len) | if (nums > dst->len) | ||||
nums = dst->len; | nums = dst->len; | ||||
dst->len = nums; | dst->len = nums; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
memcpy(dst->data.cstr, src->data.cstr, nums); | memcpy(dst->data.cstr, src->data.cstr, nums); | ||||
dst->data.cstr[dst->len] = '\0'; | dst->data.cstr[dst->len] = '\0'; | ||||
} else { | } else { | ||||
memcpy(dst->data.wstr, src->data.wstr, | memcpy(dst->data.wstr, src->data.wstr, | ||||
SIZEOF_WCHAR_STRING(nums + 1)); | SIZEOF_WCHAR_STRING(nums + 1)); | ||||
dst->data.wstr[dst->len] = L'\0'; | dst->data.wstr[dst->len] = L'\0'; | ||||
} | } | ||||
Show All 12 Lines | bwsncpy(struct bwstring *dst, const struct bwstring *src, size_t size) | ||||
size_t nums = src->len; | size_t nums = src->len; | ||||
if (nums > dst->len) | if (nums > dst->len) | ||||
nums = dst->len; | nums = dst->len; | ||||
if (nums > size) | if (nums > size) | ||||
nums = size; | nums = size; | ||||
dst->len = nums; | dst->len = nums; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
memcpy(dst->data.cstr, src->data.cstr, nums); | memcpy(dst->data.cstr, src->data.cstr, nums); | ||||
dst->data.cstr[dst->len] = '\0'; | dst->data.cstr[dst->len] = '\0'; | ||||
} else { | } else { | ||||
memcpy(dst->data.wstr, src->data.wstr, | memcpy(dst->data.wstr, src->data.wstr, | ||||
SIZEOF_WCHAR_STRING(nums + 1)); | SIZEOF_WCHAR_STRING(nums + 1)); | ||||
dst->data.wstr[dst->len] = L'\0'; | dst->data.wstr[dst->len] = L'\0'; | ||||
} | } | ||||
Show All 18 Lines | bwsnocpy(struct bwstring *dst, const struct bwstring *src, size_t offset, | ||||
} else { | } else { | ||||
size_t nums = src->len - offset; | size_t nums = src->len - offset; | ||||
if (nums > dst->len) | if (nums > dst->len) | ||||
nums = dst->len; | nums = dst->len; | ||||
if (nums > size) | if (nums > size) | ||||
nums = size; | nums = size; | ||||
dst->len = nums; | dst->len = nums; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
memcpy(dst->data.cstr, src->data.cstr + offset, | memcpy(dst->data.cstr, src->data.cstr + offset, | ||||
(nums)); | (nums)); | ||||
dst->data.cstr[dst->len] = '\0'; | dst->data.cstr[dst->len] = '\0'; | ||||
} else { | } else { | ||||
memcpy(dst->data.wstr, src->data.wstr + offset, | memcpy(dst->data.wstr, src->data.wstr + offset, | ||||
SIZEOF_WCHAR_STRING(nums)); | SIZEOF_WCHAR_STRING(nums)); | ||||
dst->data.wstr[dst->len] = L'\0'; | dst->data.wstr[dst->len] = L'\0'; | ||||
} | } | ||||
} | } | ||||
return (dst); | return (dst); | ||||
} | } | ||||
/* | /* | ||||
* Write binary string to the file. | * Write binary string to the file. | ||||
* The output is ended either with '\n' (nl == true) | * The output is ended either with '\n' (nl == true) | ||||
* or '\0' (nl == false). | * or '\0' (nl == false). | ||||
*/ | */ | ||||
size_t | size_t | ||||
bwsfwrite(struct bwstring *bws, FILE *f, bool zero_ended) | bwsfwrite(struct bwstring *bws, FILE *f, bool zero_ended) | ||||
{ | { | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
size_t len = bws->len; | size_t len = bws->len; | ||||
if (!zero_ended) { | if (!zero_ended) { | ||||
bws->data.cstr[len] = '\n'; | bws->data.cstr[len] = '\n'; | ||||
if (fwrite(bws->data.cstr, len + 1, 1, f) < 1) | if (fwrite(bws->data.cstr, len + 1, 1, f) < 1) | ||||
err(2, NULL); | err(2, NULL); | ||||
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines | |||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
bwsfgetln(FILE *f, size_t *len, bool zero_ended, struct reader_buffer *rb) | bwsfgetln(FILE *f, size_t *len, bool zero_ended, struct reader_buffer *rb) | ||||
{ | { | ||||
wint_t eols; | wint_t eols; | ||||
eols = zero_ended ? btowc('\0') : btowc('\n'); | eols = zero_ended ? btowc('\0') : btowc('\n'); | ||||
if (!zero_ended && (MB_CUR_MAX > 1)) { | if (!zero_ended && (mb_cur_max > 1)) { | ||||
wchar_t *ret; | wchar_t *ret; | ||||
ret = fgetwln(f, len); | ret = fgetwln(f, len); | ||||
if (ret == NULL) { | if (ret == NULL) { | ||||
if (!feof(f)) | if (!feof(f)) | ||||
err(2, NULL); | err(2, NULL); | ||||
return (NULL); | return (NULL); | ||||
} | } | ||||
if (*len > 0) { | if (*len > 0) { | ||||
if (ret[*len - 1] == (wchar_t)eols) | if (ret[*len - 1] == (wchar_t)eols) | ||||
--(*len); | --(*len); | ||||
} | } | ||||
return (bwssbdup(ret, *len)); | return (bwssbdup(ret, *len)); | ||||
} else if (!zero_ended && (MB_CUR_MAX == 1)) { | } else if (!zero_ended && (mb_cur_max == 1)) { | ||||
char *ret; | char *ret; | ||||
ret = fgetln(f, len); | ret = fgetln(f, len); | ||||
if (ret == NULL) { | if (ret == NULL) { | ||||
if (!feof(f)) | if (!feof(f)) | ||||
err(2, NULL); | err(2, NULL); | ||||
return (NULL); | return (NULL); | ||||
Show All 12 Lines | if (!zero_ended && (mb_cur_max > 1)) { | ||||
if (2 >= rb->fgetwln_z_buffer_size) { | if (2 >= rb->fgetwln_z_buffer_size) { | ||||
rb->fgetwln_z_buffer_size += 256; | rb->fgetwln_z_buffer_size += 256; | ||||
rb->fgetwln_z_buffer = sort_realloc(rb->fgetwln_z_buffer, | rb->fgetwln_z_buffer = sort_realloc(rb->fgetwln_z_buffer, | ||||
sizeof(wchar_t) * rb->fgetwln_z_buffer_size); | sizeof(wchar_t) * rb->fgetwln_z_buffer_size); | ||||
} | } | ||||
rb->fgetwln_z_buffer[*len] = 0; | rb->fgetwln_z_buffer[*len] = 0; | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
while (!feof(f)) { | while (!feof(f)) { | ||||
int c; | int c; | ||||
c = fgetc(f); | c = fgetc(f); | ||||
if (c == EOF) { | if (c == EOF) { | ||||
if (*len == 0) | if (*len == 0) | ||||
return (NULL); | return (NULL); | ||||
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines | else { | ||||
cmp_len = len1; | cmp_len = len1; | ||||
if (len2 < cmp_len) | if (len2 < cmp_len) | ||||
cmp_len = len2; | cmp_len = len2; | ||||
if (len < cmp_len) | if (len < cmp_len) | ||||
cmp_len = len; | cmp_len = len; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
const unsigned char *s1, *s2; | const unsigned char *s1, *s2; | ||||
s1 = bws1->data.cstr + offset; | s1 = bws1->data.cstr + offset; | ||||
s2 = bws2->data.cstr + offset; | s2 = bws2->data.cstr + offset; | ||||
res = memcmp(s1, s2, cmp_len); | res = memcmp(s1, s2, cmp_len); | ||||
} else { | } else { | ||||
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines | if (len1 <= offset) | ||||
return ((len2 <= offset) ? 0 : -1); | return ((len2 <= offset) ? 0 : -1); | ||||
else { | else { | ||||
if (len2 <= offset) | if (len2 <= offset) | ||||
return (+1); | return (+1); | ||||
else { | else { | ||||
len1 -= offset; | len1 -= offset; | ||||
len2 -= offset; | len2 -= offset; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
const unsigned char *s1, *s2; | const unsigned char *s1, *s2; | ||||
s1 = bws1->data.cstr + offset; | s1 = bws1->data.cstr + offset; | ||||
s2 = bws2->data.cstr + offset; | s2 = bws2->data.cstr + offset; | ||||
if (byte_sort) { | if (byte_sort) { | ||||
int res = 0; | int res = 0; | ||||
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines | |||||
/* | /* | ||||
* Correction of the system API | * Correction of the system API | ||||
*/ | */ | ||||
double | double | ||||
bwstod(struct bwstring *s0, bool *empty) | bwstod(struct bwstring *s0, bool *empty) | ||||
{ | { | ||||
double ret = 0; | double ret = 0; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
unsigned char *end, *s; | unsigned char *end, *s; | ||||
char *ep; | char *ep; | ||||
s = s0->data.cstr; | s = s0->data.cstr; | ||||
end = s + s0->len; | end = s + s0->len; | ||||
ep = NULL; | ep = NULL; | ||||
while (isblank(*s) && s < end) | while (isblank(*s) && s < end) | ||||
Show All 40 Lines | |||||
* a month name, it returns (number of the month - 1), | * a month name, it returns (number of the month - 1), | ||||
* while if there is no match, it just return -1. | * while if there is no match, it just return -1. | ||||
*/ | */ | ||||
int | int | ||||
bws_month_score(const struct bwstring *s0) | bws_month_score(const struct bwstring *s0) | ||||
{ | { | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
const unsigned char *end, *s; | const unsigned char *end, *s; | ||||
s = s0->data.cstr; | s = s0->data.cstr; | ||||
end = s + s0->len; | end = s + s0->len; | ||||
while (isblank(*s) && s < end) | while (isblank(*s) && s < end) | ||||
++s; | ++s; | ||||
Show All 23 Lines | |||||
/* | /* | ||||
* Rips out leading blanks (-b). | * Rips out leading blanks (-b). | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
ignore_leading_blanks(struct bwstring *str) | ignore_leading_blanks(struct bwstring *str) | ||||
{ | { | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
unsigned char *dst, *end, *src; | unsigned char *dst, *end, *src; | ||||
src = str->data.cstr; | src = str->data.cstr; | ||||
dst = src; | dst = src; | ||||
end = src + str->len; | end = src + str->len; | ||||
while (src < end && isblank(*src)) | while (src < end && isblank(*src)) | ||||
++src; | ++src; | ||||
Show All 39 Lines | |||||
/* | /* | ||||
* Rips out nonprinting characters (-i). | * Rips out nonprinting characters (-i). | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
ignore_nonprinting(struct bwstring *str) | ignore_nonprinting(struct bwstring *str) | ||||
{ | { | ||||
size_t newlen = str->len; | size_t newlen = str->len; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
unsigned char *dst, *end, *src; | unsigned char *dst, *end, *src; | ||||
unsigned char c; | unsigned char c; | ||||
src = str->data.cstr; | src = str->data.cstr; | ||||
dst = src; | dst = src; | ||||
end = src + str->len; | end = src + str->len; | ||||
while (src < end) { | while (src < end) { | ||||
Show All 36 Lines | |||||
* Rips out any characters that are not alphanumeric characters | * Rips out any characters that are not alphanumeric characters | ||||
* nor blanks (-d). | * nor blanks (-d). | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
dictionary_order(struct bwstring *str) | dictionary_order(struct bwstring *str) | ||||
{ | { | ||||
size_t newlen = str->len; | size_t newlen = str->len; | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
unsigned char *dst, *end, *src; | unsigned char *dst, *end, *src; | ||||
unsigned char c; | unsigned char c; | ||||
src = str->data.cstr; | src = str->data.cstr; | ||||
dst = src; | dst = src; | ||||
end = src + str->len; | end = src + str->len; | ||||
while (src < end) { | while (src < end) { | ||||
Show All 34 Lines | |||||
/* | /* | ||||
* Converts string to lower case(-f). | * Converts string to lower case(-f). | ||||
*/ | */ | ||||
struct bwstring * | struct bwstring * | ||||
ignore_case(struct bwstring *str) | ignore_case(struct bwstring *str) | ||||
{ | { | ||||
if (MB_CUR_MAX == 1) { | if (mb_cur_max == 1) { | ||||
unsigned char *end, *s; | unsigned char *end, *s; | ||||
s = str->data.cstr; | s = str->data.cstr; | ||||
end = s + str->len; | end = s + str->len; | ||||
while (s < end) { | while (s < end) { | ||||
*s = toupper(*s); | *s = toupper(*s); | ||||
++s; | ++s; | ||||
Show All 11 Lines | ignore_case(struct bwstring *str) | ||||
} | } | ||||
return (str); | return (str); | ||||
} | } | ||||
void | void | ||||
bws_disorder_warnx(struct bwstring *s, const char *fn, size_t pos) | bws_disorder_warnx(struct bwstring *s, const char *fn, size_t pos) | ||||
{ | { | ||||
if (MB_CUR_MAX == 1) | if (mb_cur_max == 1) | ||||
warnx("%s:%zu: disorder: %s", fn, pos + 1, s->data.cstr); | warnx("%s:%zu: disorder: %s", fn, pos + 1, s->data.cstr); | ||||
else | else | ||||
warnx("%s:%zu: disorder: %ls", fn, pos + 1, s->data.wstr); | warnx("%s:%zu: disorder: %ls", fn, pos + 1, s->data.wstr); | ||||
} | } |