miscellaneous cleanups for the multibyte parsing functions

git-svn-id: svn://svn.savannah.gnu.org/nano/trunk/nano@2242 35c25a1d-7b9e-4130-9fde-d3aeb78583b8

diff --git a/src/nano.c b/src/nano.c
index b9ba1cd93f65f3b4667f8ab1e601c2d9c901f35d..5027dd386fd6b780036a1e4269a5c5a4382a0831 100644 (file)
--- a/src/nano.c
+++ b/src/nano.c
@@ -1178,12 +1178,11 @@ void do_delete(void)
     placewewant = xplustabs();
 
     if (current->data[current_x] != '\0') {
-       int char_len = parse_char(current->data + current_x, NULL,
-               NULL
+       int char_len = parse_char(current->data + current_x, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , NULL);
        size_t line_len = strlen(current->data + current_x);
 
        assert(current_x < strlen(current->data));
@@ -2501,11 +2500,11 @@ bool breakable(const char *line, ssize_t goal)
        if (isblank(*line))
            return TRUE;
 
-       line += parse_char(line, NULL, &pos
+       line += parse_char(line, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , &pos);
 
        goal -= pos;
     }
@@ -2539,11 +2538,11 @@ ssize_t break_line(const char *line, ssize_t goal, bool force)
 
        assert(*line != '\t');
 
-       line_len = parse_char(line, NULL, &pos
+       line_len = parse_char(line, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , &pos);
 
        goal -= pos;
        line += line_len;

diff --git a/src/proto.h b/src/proto.h
index 6801d0a6c935b7f1a0d9a1815c9022abd1a3e82b..7bcb673276b4ba030506ecd0bc9a4528775cc3b8 100644 (file)
--- a/src/proto.h
+++ b/src/proto.h
@@ -478,13 +478,13 @@ bool is_byte_char(int c);
 int num_of_digits(int n);
 unsigned char control_rep(unsigned char c);
 bool parse_num(const char *str, ssize_t *val);
-int parse_char(const char *str, int *chr, size_t *col
+int parse_char(const char *buf, int *chr
 #ifdef NANO_WIDE
-       , bool *bad_char
+       , bool *bad_chr
 #endif
-       );
-size_t move_left(const char *str, size_t pos);
-size_t move_right(const char *str, size_t pos);
+       , size_t *col);
+size_t move_left(const char *buf, size_t pos);
+size_t move_right(const char *buf, size_t pos);
 void align(char **strp);
 void null_at(char **data, size_t index);
 void unsunder(char *str, size_t true_len);

diff --git a/src/utils.c b/src/utils.c
index 4b3c918b44fa64aba31d1953eafffc0b8ad782c8..dc95b95f592ff1bc464f6656a3340f4e2790abf3 100644 (file)
--- a/src/utils.c
+++ b/src/utils.c
@@ -128,66 +128,66 @@ bool parse_num(const char *str, ssize_t *val)
     return TRUE;
 }
 
-/* Parse a multi-byte character from str.  Return the number of bytes
- * used.  If chr isn't NULL, store the wide character in it.  If col
- * isn't NULL, store the new display width in it.  If *str is '\t', we
- * expect col to have the current display width.  If bad_char isn't
- * NULL, set it to TRUE if we have a null byte or a bad multibyte
- * character. */
-int parse_char(const char *str, int *chr, size_t *col
+/* Parse a multibyte character from buf.  Return the number of bytes
+ * used.  If chr isn't NULL, store the wide character in it.  If
+ * bad_chr isn't NULL, set it to TRUE if we have a null byte or a bad
+ * multibyte character.  If col isn't NULL, store the new display width
+ * in it.  If *str is '\t', we expect col to have the current display
+ * width. */
+int parse_char(const char *buf, int *chr
 #ifdef NANO_WIDE
-       , bool *bad_char
+       , bool *bad_chr
 #endif
-       )
+       , size_t *col)
 {
-    int wide_str, wide_str_len;
+    int wide_buf, mb_buf_len;
 
-    assert(str != NULL);
+    assert(buf != NULL);
 
 #ifdef NANO_WIDE
-    if (bad_char != NULL)
-       *bad_char = FALSE;
+    if (bad_chr != NULL)
+       *bad_chr = FALSE;
 
     if (!ISSET(NO_UTF8)) {
        wchar_t tmp;
 
        /* Get the wide character equivalent of the multibyte
         * character. */
-       wide_str_len = mbtowc(&tmp, str, MB_CUR_MAX);
-       wide_str = (int)tmp;
-
-       /* If str contains a null byte or an invalid multibyte
-        * character, interpret str's first byte as a single-byte
-        * sequence and set bad_char to TRUE. */
-       if (wide_str_len <= 0) {
-           wide_str_len = 1;
-           wide_str = (unsigned char)*str;
-           if (bad_char != NULL)
-               *bad_char = TRUE;
+       mb_buf_len = mbtowc(&tmp, buf, MB_CUR_MAX);
+       wide_buf = (int)tmp;
+
+       /* If buf contains a null byte or an invalid multibyte
+        * character, interpret buf's first byte as a single-byte
+        * sequence and set bad_chr to TRUE. */
+       if (mb_buf_len <= 0) {
+           mb_buf_len = 1;
+           wide_buf = (unsigned char)*buf;
+           if (bad_chr != NULL)
+               *bad_chr = TRUE;
        }
 
        /* Save the wide character in chr. */
        if (chr != NULL)
-           *chr = wide_str;
+           *chr = wide_buf;
 
        /* Save the column width of the wide character in col. */
        if (col != NULL) {
            /* If we have a tab, get its width in columns using the
             * current value of col. */
-           if (wide_str == '\t')
+           if (wide_buf == '\t')
                *col += tabsize - *col % tabsize;
            /* If we have a control character, get its width using one
             * column for the "^" that will be displayed in front of it,
             * and the width in columns of its visible equivalent as
             * returned by control_rep(). */
-           else if (is_cntrl_char(wide_str)) {
-               char *ctrl_wide_str = charalloc(MB_CUR_MAX);
+           else if (is_cntrl_char(wide_buf)) {
+               char *ctrl_mb_buf = charalloc(MB_CUR_MAX);
 
                (*col)++;
-               wide_str = control_rep((unsigned char)wide_str);
+               wide_buf = control_rep((unsigned char)wide_buf);
 
-               if (wctomb(ctrl_wide_str, (wchar_t)wide_str) != -1) {
-                   int width = wcwidth(wide_str);
+               if (wctomb(ctrl_mb_buf, (wchar_t)wide_buf) != -1) {
+                   int width = wcwidth((wchar_t)wide_buf);
 
                    if (width != -1)
                        *col += width;
@@ -195,11 +195,11 @@ int parse_char(const char *str, int *chr, size_t *col
                else
                    (*col)++;
 
-               free(ctrl_wide_str);
+               free(ctrl_mb_buf);
            /* If we have a normal character, get its width in columns
             * normally. */
            } else {
-               int width = wcwidth(wide_str);
+               int width = wcwidth((wchar_t)wide_buf);
 
                if (width != -1)
                    *col += width;
@@ -207,25 +207,25 @@ int parse_char(const char *str, int *chr, size_t *col
        }
     } else {
 #endif
-       /* Interpret str's first character as a single-byte sequence. */
-       wide_str_len = 1;
-       wide_str = (unsigned char)*str;
+       /* Interpret buf's first character as a single-byte sequence. */
+       mb_buf_len = 1;
+       wide_buf = (unsigned char)*buf;
 
        /* Save the single-byte sequence in chr as though it's a wide
         * character. */
        if (chr != NULL)
-           *chr = wide_str;
+           *chr = wide_buf;
 
        if (col != NULL) {
            /* If we have a tab, get its width in columns using the
             * current value of col. */
-           if (wide_str == '\t')
+           if (wide_buf == '\t')
                *col += tabsize - *col % tabsize;
            /* If we have a control character, it's two columns wide:
             * one column for the "^" that will be displayed in front of
             * it, and one column for its visible equivalent as returned
             * by control_rep(). */
-           else if (is_cntrl_char(wide_str))
+           else if (is_cntrl_char(wide_buf))
                *col += 2;
            /* If we have a normal character, it's one column wide. */
            else
@@ -235,44 +235,44 @@ int parse_char(const char *str, int *chr, size_t *col
     }
 #endif
 
-    return wide_str_len;
+    return mb_buf_len;
 }
 
-/* Return the index in str of the beginning of the character before the
+/* Return the index in buf of the beginning of the character before the
  * one at pos. */
-size_t move_left(const char *str, size_t pos)
+size_t move_left(const char *buf, size_t pos)
 {
     size_t pos_prev = pos;
 
-    assert(str != NULL && pos <= strlen(str));
+    assert(str != NULL && pos <= strlen(buf));
 
     /* There is no library function to move backward one multibyte
      * character.  Here is the naive, O(pos) way to do it. */
     while (TRUE) {
-       int str_len = parse_char(str + pos - pos_prev, NULL, NULL
+       int mb_buf_len = parse_char(buf + pos - pos_prev, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , NULL);
 
-       if (pos_prev <= str_len)
+       if (pos_prev <= mb_buf_len)
            break;
 
-       pos_prev -= str_len;
+       pos_prev -= mb_buf_len;
     }
 
     return pos - pos_prev;
 }
 
-/* Return the index in str of the beginning of the character after the
+/* Return the index in buf of the beginning of the character after the
  * one at pos. */
-size_t move_right(const char *str, size_t pos)
+size_t move_right(const char *buf, size_t pos)
 {
-    return pos + parse_char(str + pos, NULL, NULL
+    return pos + parse_char(buf + pos, NULL
 #ifdef NANO_WIDE
        , NULL
 #endif
-       );
+       , NULL);
 }
 
 /* Fix the memory allocation for a string. */

diff --git a/src/winio.c b/src/winio.c
index 36868c98ec35bda73e3e75d54b40081f188c04ca..f4e55dbd40d350cf06dbc65b292f3062c1a1532f 100644 (file)
--- a/src/winio.c
+++ b/src/winio.c
@@ -1936,11 +1936,11 @@ void do_statusbar_backspace(void)
 void do_statusbar_delete(void)
 {
     if (statusbar_x < statusbar_xend) {
-       int char_len = parse_char(answer + statusbar_x, NULL, NULL
+       int char_len = parse_char(answer + statusbar_x, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , NULL);
 
        charmove(answer + statusbar_x, answer + statusbar_x + char_len,
                statusbar_xend - statusbar_x - char_len + 1);
@@ -2056,11 +2056,11 @@ size_t actual_x(const char *str, size_t xplus)
     assert(str != NULL);
 
     while (*str != '\0') {
-       int str_len = parse_char(str, NULL, &length
+       int str_len = parse_char(str, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , &length);
 
        if (length > xplus)
            break;
@@ -2085,11 +2085,11 @@ size_t strnlenpt(const char *str, size_t size)
     assert(str != NULL);
 
     while (*str != '\0') {
-       int str_len = parse_char(str, NULL, &length
+       int str_len = parse_char(str, NULL
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , &length);
 
        str += str_len;
 
@@ -2160,25 +2160,25 @@ size_t display_string_len(const char *buf, size_t start_col, size_t
     /* Throughout the loop, we maintain the fact that *buf displays at
      * column start_col. */
     while (start_col <= end_col && *buf != '\0') {
-       int wide_buf, wide_buf_len;
-       size_t old_col = start_col;
+       int wide_buf, mb_buf_len;
 #ifdef NANO_WIDE
        bool bad_char;
 #endif
+       size_t old_col = start_col;
 
-       wide_buf_len = parse_char(buf, &wide_buf, &start_col
+       mb_buf_len = parse_char(buf, &wide_buf
 #ifdef NANO_WIDE
                , &bad_char
 #endif
-               );
+               , &start_col);
 
 #ifdef NANO_WIDE
        /* If buf contains a null byte or an invalid multibyte
         * character, interpret that character as though it's a wide
         * character. */
        if (!ISSET(NO_UTF8) && bad_char) {
-           char *bad_wide_buf = charalloc(MB_CUR_MAX);
-           int bad_wide_buf_len;
+           char *bad_mb_buf = charalloc(MB_CUR_MAX);
+           int bad_mb_buf_len;
 
            /* If we have a control character, add one byte to account
             * for the "^" that will be displayed in front of it, and
@@ -2191,12 +2191,12 @@ size_t display_string_len(const char *buf, size_t start_col, size_t
 
            /* Translate the wide character to its multibyte
             * equivalent. */
-           bad_wide_buf_len = wctomb(bad_wide_buf, (wchar_t)wide_buf);
+           bad_mb_buf_len = wctomb(bad_mb_buf, (wchar_t)wide_buf);
 
-           if (bad_wide_buf_len != -1)
-               retval += bad_wide_buf_len;
+           if (bad_mb_buf_len != -1)
+               retval += bad_mb_buf_len;
 
-           free(bad_wide_buf);
+           free(bad_mb_buf);
        } else {
 #endif
            /* If we have a tab, get its width in bytes using the
@@ -2208,23 +2208,22 @@ size_t display_string_len(const char *buf, size_t start_col, size_t
             * then add the number of bytes for its visible equivalent
             * as returned by control_rep(). */
            else if (is_cntrl_char(wide_buf)) {
-               char ctrl_wide_buf =
-                       control_rep((unsigned char)wide_buf);
+               char ctrl_mb_buf = control_rep((unsigned char)wide_buf);
 
                retval++;
-               retval += parse_char(&ctrl_wide_buf, NULL, NULL
+               retval += parse_char(&ctrl_mb_buf, NULL
 #ifdef NANO_WIDE
                        , NULL
 #endif
-                       );
+                       , NULL);
            /* If we have a normal character, add its width in bytes
             * normally. */
            } else
-               retval += wide_buf_len;
+               retval += mb_buf_len;
 #ifdef NANO_WIDE
        }
 
-       buf += wide_buf_len;
+       buf += mb_buf_len;
 #endif
     }
 
@@ -2279,43 +2278,43 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
 
     if (column < start_col || (dollars && column > 0 &&
        buf[start_index] != '\t')) {
-       int wide_buf, wide_buf_len;
+       int wide_buf, mb_buf_len;
 
        /* We don't display all of buf[start_index] since it starts to
         * the left of the screen. */
-       wide_buf_len = parse_char(buf + start_index, &wide_buf, NULL
+       mb_buf_len = parse_char(buf + start_index, &wide_buf
 #ifdef NANO_WIDE
                , NULL
 #endif
-               );
+               , NULL);
 
        if (is_cntrl_char(wide_buf)) {
            if (column < start_col) {
-               char *ctrl_wide_buf =
+               char *ctrl_mb_buf =
 #ifdef NANO_WIDE
                        !ISSET(NO_UTF8) ? charalloc(MB_CUR_MAX) :
 #endif
                        charalloc(1);
-               int ctrl_wide_buf_len, i;
+               int ctrl_mb_buf_len, i;
 
                wide_buf = control_rep((unsigned char)wide_buf);
 
 #ifdef NANO_WIDE
                if (!ISSET(NO_UTF8))
-                   ctrl_wide_buf_len = wctomb(ctrl_wide_buf,
+                   ctrl_mb_buf_len = wctomb(ctrl_mb_buf,
                        (wchar_t)wide_buf);
                else {
 #endif
-                   ctrl_wide_buf_len = 1;
-                   ctrl_wide_buf[0] = (unsigned char)wide_buf;
+                   ctrl_mb_buf_len = 1;
+                   ctrl_mb_buf[0] = (unsigned char)wide_buf;
 #ifdef NANO_WIDE
                }
 #endif
 
-               for (i = 0; i < ctrl_wide_buf_len; i++)
-                   converted[index++] = ctrl_wide_buf[i];
+               for (i = 0; i < ctrl_mb_buf_len; i++)
+                   converted[index++] = ctrl_mb_buf[i];
 
-               free(ctrl_wide_buf);
+               free(ctrl_mb_buf);
 
 #ifdef NANO_WIDE
                if (!ISSET(NO_UTF8)) {
@@ -2327,7 +2326,7 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
 #endif
                    start_col++;
 
-               start_index += wide_buf_len;
+               start_index += mb_buf_len;
            }
        }
 #ifdef NANO_WIDE
@@ -2335,22 +2334,22 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
            converted[index++] = ' ';
 
            start_col++;
-           start_index += wide_buf_len;
+           start_index += mb_buf_len;
        }
 #endif
     }
 
     while (index < alloc_len - 1 && buf[start_index] != '\0') {
-       int wide_buf, wide_buf_len;
+       int wide_buf, mb_buf_len;
 #ifdef NANO_WIDE
        bool bad_char;
 #endif
 
-       wide_buf_len = parse_char(buf + start_index, &wide_buf, NULL
+       mb_buf_len = parse_char(buf + start_index, &wide_buf
 #ifdef NANO_WIDE
                , &bad_char
 #endif
-               );
+               , NULL);
 
        if (wide_buf == '\t') {
            converted[index++] =
@@ -2367,12 +2366,12 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
         * contains an invalid multibyte control character, interpret
         * that character as though it's a normal control character. */
        } else if (is_cntrl_char(wide_buf)) {
-           char *ctrl_wide_buf =
+           char *ctrl_mb_buf =
 #ifdef NANO_WIDE
                !ISSET(NO_UTF8) ? charalloc(MB_CUR_MAX) :
 #endif
                charalloc(1);
-           int ctrl_wide_buf_len, i;
+           int ctrl_mb_buf_len, i;
 
            converted[index++] = '^';
            start_col++;
@@ -2380,20 +2379,20 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
 
 #ifdef NANO_WIDE
            if (!ISSET(NO_UTF8))
-               ctrl_wide_buf_len = wctomb(ctrl_wide_buf,
+               ctrl_mb_buf_len = wctomb(ctrl_mb_buf,
                        (wchar_t)wide_buf);
            else {
 #endif
-               ctrl_wide_buf_len = 1;
-               ctrl_wide_buf[0] = (unsigned char)wide_buf;
+               ctrl_mb_buf_len = 1;
+               ctrl_mb_buf[0] = (unsigned char)wide_buf;
 #ifdef NANO_WIDE
            }
 #endif
 
-           for (i = 0; i < ctrl_wide_buf_len; i++)
-               converted[index++] = ctrl_wide_buf[i];
+           for (i = 0; i < ctrl_mb_buf_len; i++)
+               converted[index++] = ctrl_mb_buf[i];
 
-           free(ctrl_wide_buf);
+           free(ctrl_mb_buf);
 
 #ifdef NANO_WIDE
            if (!ISSET(NO_UTF8)) {
@@ -2419,19 +2418,18 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
             * character, interpret that character as though it's a
             * normal non-control character. */
            if (!ISSET(NO_UTF8) && bad_char) {
-               char *bad_wide_buf = charalloc(MB_CUR_MAX);
-               int bad_wide_buf_len;
+               char *bad_mb_buf = charalloc(MB_CUR_MAX);
+               int bad_mb_buf_len;
 
-               bad_wide_buf_len = wctomb(bad_wide_buf,
-                       (wchar_t)wide_buf);
+               bad_mb_buf_len = wctomb(bad_mb_buf, (wchar_t)wide_buf);
 
-               for (i = 0; i < bad_wide_buf_len; i++)
-                   converted[index++] = bad_wide_buf[i];
+               for (i = 0; i < bad_mb_buf_len; i++)
+                   converted[index++] = bad_mb_buf[i];
 
-               free(bad_wide_buf);
+               free(bad_mb_buf);
            } else {
 #endif
-               for (i = 0; i < wide_buf_len; i++)
+               for (i = 0; i < mb_buf_len; i++)
                    converted[index++] = buf[start_index + i];
 #ifdef NANO_WIDE
            }
@@ -2446,7 +2444,7 @@ char *display_string(const char *buf, size_t start_col, size_t len, bool
                start_col++;
        }
 
-       start_index += wide_buf_len;
+       start_index += mb_buf_len;
     }
 
     if (index < alloc_len - 1)