Changes in / [e866806:1df977c] in mainline


Ignore:
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/string.h

    re866806 r1df977c  
    8787extern void str_cpy(char *dest, size_t size, const char *src);
    8888extern void str_ncpy(char *dest, size_t size, const char *src, size_t n);
    89 extern void wstr_to_str(char *dest, size_t size, const wchar_t *src);
     89extern void wstr_nstr(char *dst, const wchar_t *src, size_t size);
    9090
    9191extern char *str_chr(const char *str, wchar_t ch);

  • kernel/generic/src/console/kconsole.c

    re866806 r1df977c  
    289289                       
    290290                        char tmp[STR_BOUNDS(MAX_CMDLINE)];
    291                         wstr_to_str(tmp, position - beg + 1, current + beg);
     291                        wstr_nstr(tmp, current + beg, position - beg + 1);
    292292                       
    293293                        int found;
    … …  
    665665               
    666666                char cmdline[STR_BOUNDS(MAX_CMDLINE)];
    667                 wstr_to_str(cmdline, STR_BOUNDS(MAX_CMDLINE), tmp);
     667                wstr_nstr(cmdline, tmp, STR_BOUNDS(MAX_CMDLINE));
    668668               
    669669                if ((!kcon) && (len == 4) && (str_lcmp(cmdline, "exit", 4) == 0))

  • kernel/generic/src/lib/string.c

    re866806 r1df977c  
    537537 * null-terminated and containing only complete characters.
    538538 *
    539  * @param dest   Destination buffer.
     539 * @param dst   Destination buffer.
    540540 * @param count Size of the destination buffer (must be > 0).
    541541 * @param src   Source string.
    … …  
    571571 * have to be null-terminated.
    572572 *
    573  * @param dest   Destination buffer.
     573 * @param dst   Destination buffer.
    574574 * @param count Size of the destination buffer (must be > 0).
    575575 * @param src   Source string.
    … …  
    596596}
    597597
    598 /** Convert wide string to string.
    599  *
    600  * Convert wide string @a src to string. The output is written to the buffer
    601  * specified by @a dest and @a size. @a size must be non-zero and the string
    602  * written will always be well-formed.
    603  *
    604  * @param dest  Destination buffer.
    605  * @param size  Size of the destination buffer.
    606  * @param src   Source wide string.
    607  */
    608 void wstr_to_str(char *dest, size_t size, const wchar_t *src)
    609 {
     598/** Copy NULL-terminated wide string to string
     599 *
     600 * Copy source wide string @a src to destination buffer @a dst.
     601 * No more than @a size bytes are written. NULL-terminator is always
     602 * written after the last succesfully copied character (i.e. if the
     603 * destination buffer is has at least 1 byte, it will be always
     604 * NULL-terminated).
     605 *
     606 * @param src   Source wide string.
     607 * @param dst   Destination buffer.
     608 * @param count Size of the destination buffer.
     609 *
     610 */
     611void wstr_nstr(char *dst, const wchar_t *src, size_t size)
     612{
     613        /* No space for the NULL-terminator in the buffer */
     614        if (size == 0)
     615                return;
     616       
    610617        wchar_t ch;
    611         size_t src_idx;
    612         size_t dest_off;
    613 
    614         /* There must be space for a null terminator in the buffer. */
    615         ASSERT(size > 0);
    616 
    617         src_idx = 0;
    618         dest_off = 0;
     618        size_t src_idx = 0;
     619        size_t dst_off = 0;
    619620       
    620621        while ((ch = src[src_idx++]) != 0) {
    621                 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
     622                if (chr_encode(ch, dst, &dst_off, size) != EOK)
    622623                        break;
    623624        }
    624 
    625         dest[dest_off] = '\0';
     625       
     626        if (dst_off >= size)
     627                dst[size - 1] = 0;
     628        else
     629                dst[dst_off] = 0;
    626630}
    627631

  • uspace/app/bdsh/input.c

    re866806 r1df977c  
    134134static char *tinput_get_str(tinput_t *ti)
    135135{
    136         return wstr_to_astr(ti->buffer);
     136        char *str;
     137
     138        str = malloc(STR_BOUNDS(ti->nc) + 1);
     139        if (str == NULL)
     140                return NULL;
     141
     142        wstr_nstr(str, ti->buffer, STR_BOUNDS(ti->nc) + 1);
     143
     144        return str;
    137145}
    138146

  • uspace/app/edit/edit.c

    re866806 r1df977c  
    102102#define ED_INFTY 65536
    103103
    104 /** Maximum filename length that can be entered. */
    105 #define INFNAME_MAX_LEN 128
    106 
    107104static void key_handle_unmod(console_event_t const *ev);
    108105static void key_handle_ctrl(console_event_t const *ev);
    … …  
    334331}
    335332
     333#define INPUT_MAX_LEN 64
     334
    336335/** Ask for a file name. */
    337336static char *filename_prompt(char const *prompt, char const *init_value)
    … …  
    339338        console_event_t ev;
    340339        char *str;
    341         wchar_t buffer[INFNAME_MAX_LEN + 1];
    342         int max_len;
     340        wchar_t buffer[INPUT_MAX_LEN + 1];
    343341        int nc;
    344342        bool done;
    … …  
    351349        console_set_color(con, COLOR_WHITE, COLOR_BLACK, 0);
    352350
    353         max_len = min(INFNAME_MAX_LEN, scr_columns - 4 - str_length(prompt));
    354         str_to_wstr(buffer, max_len + 1, init_value);
     351        str_to_wstr(buffer, INPUT_MAX_LEN + 1, init_value);
    355352        nc = wstr_length(buffer);
    356353        done = false;
    … …  
    379376                                        break;
    380377                                default:
    381                                         if (ev.c >= 32 && nc < max_len) {
     378                                        if (ev.c >= 32 && nc < INPUT_MAX_LEN) {
    382379                                                putchar(ev.c);
    383380                                                fflush(stdout);
    … …  
    391388
    392389        buffer[nc] = '\0';
    393         str = wstr_to_astr(buffer);
     390
     391        str = malloc(STR_BOUNDS(wstr_length(buffer)) + 1);
     392        if (str == NULL)
     393                return NULL;
     394
     395        wstr_nstr(str, buffer, STR_BOUNDS(wstr_length(buffer)) + 1);
    394396
    395397        console_set_color(con, COLOR_BLACK, COLOR_WHITE, 0);

  • uspace/lib/libc/generic/string.c

    re866806 r1df977c  
    471471 * null-terminated and containing only complete characters.
    472472 *
    473  * @param dest   Destination buffer.
     473 * @param dst   Destination buffer.
    474474 * @param count Size of the destination buffer (must be > 0).
    475475 * @param src   Source string.
    … …  
    505505 * have to be null-terminated.
    506506 *
    507  * @param dest   Destination buffer.
     507 * @param dst   Destination buffer.
    508508 * @param count Size of the destination buffer (must be > 0).
    509509 * @param src   Source string.
    … …  
    537537 * null-terminated and containing only complete characters.
    538538 *
    539  * @param dest   Destination buffer.
     539 * @param dst   Destination buffer.
    540540 * @param count Size of the destination buffer.
    541541 * @param src   Source string.
    … …  
    549549}
    550550
    551 /** Convert wide string to string.
    552  *
    553  * Convert wide string @a src to string. The output is written to the buffer
    554  * specified by @a dest and @a size. @a size must be non-zero and the string
    555  * written will always be well-formed.
    556  *
    557  * @param dest  Destination buffer.
    558  * @param size  Size of the destination buffer.
    559  * @param src   Source wide string.
    560  */
    561 void wstr_to_str(char *dest, size_t size, const wchar_t *src)
    562 {
     551/** Copy NULL-terminated wide string to string
     552 *
     553 * Copy source wide string @a src to destination buffer @a dst.
     554 * No more than @a size bytes are written. NULL-terminator is always
     555 * written after the last succesfully copied character (i.e. if the
     556 * destination buffer is has at least 1 byte, it will be always
     557 * NULL-terminated).
     558 *
     559 * @param src   Source wide string.
     560 * @param dst   Destination buffer.
     561 * @param count Size of the destination buffer.
     562 *
     563 */
     564void wstr_nstr(char *dst, const wchar_t *src, size_t size)
     565{
     566        /* No space for the NULL-terminator in the buffer */
     567        if (size == 0)
     568                return;
     569       
    563570        wchar_t ch;
    564         size_t src_idx;
    565         size_t dest_off;
    566 
    567         /* There must be space for a null terminator in the buffer. */
    568         assert(size > 0);
    569        
    570         src_idx = 0;
    571         dest_off = 0;
    572 
     571        size_t src_idx = 0;
     572        size_t dst_off = 0;
     573       
    573574        while ((ch = src[src_idx++]) != 0) {
    574                 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
     575                if (chr_encode(ch, dst, &dst_off, size) != EOK)
    575576                        break;
    576577        }
    577 
    578         dest[dest_off] = '\0';
    579 }
    580 
    581 /** Convert wide string to new string.
    582  *
    583  * Convert wide string @a src to string. Space for the new string is allocated
    584  * on the heap.
    585  *
    586  * @param src   Source wide string.
    587  * @return      New string.
    588  */
    589 char *wstr_to_astr(const wchar_t *src)
    590 {
    591         char dbuf[STR_BOUNDS(1)];
    592         char *str;
    593         wchar_t ch;
    594 
    595         size_t src_idx;
    596         size_t dest_off;
    597         size_t dest_size;
    598 
    599         /* Compute size of encoded string. */
    600 
    601         src_idx = 0;
    602         dest_size = 0;
    603 
    604         while ((ch = src[src_idx++]) != 0) {
    605                 dest_off = 0;
    606                 if (chr_encode(ch, dbuf, &dest_off, STR_BOUNDS(1)) != EOK)
    607                         break;
    608                 dest_size += dest_off;
    609         }
    610 
    611         str = malloc(dest_size + 1);
    612         if (str == NULL)
    613                 return NULL;
    614 
    615         /* Encode string. */
    616 
    617         src_idx = 0;
    618         dest_off = 0;
    619 
    620         while ((ch = src[src_idx++]) != 0) {
    621                 if (chr_encode(ch, str, &dest_off, dest_size) != EOK)
    622                         break;
    623         }
    624 
    625         str[dest_size] = '\0';
    626         return str;
    627 }
    628 
     578       
     579        if (dst_off >= size)
     580                dst[size - 1] = 0;
     581        else
     582                dst[dst_off] = 0;
     583}
    629584
    630585/** Convert string to wide string.
    631586 *
    632587 * Convert string @a src to wide string. The output is written to the
    633  * buffer specified by @a dest and @a dlen. @a dlen must be non-zero
    634  * and the wide string written will always be null-terminated.
     588 * buffer specified by @a dest and @a size, which must have non-zero
     589 * size. The output will always be null-terminated.
    635590 *
    636591 * @param dest  Destination buffer.

  • uspace/lib/libc/include/string.h

    re866806 r1df977c  
    7373extern void str_append(char *dest, size_t size, const char *src);
    7474
    75 extern void wstr_to_str(char *dest, size_t size, const wchar_t *src);
    76 extern char *wstr_to_astr(const wchar_t *src);
     75extern void wstr_nstr(char *dst, const wchar_t *src, size_t size);
    7776extern void str_to_wstr(wchar_t *dest, size_t dlen, const char *src);
    7877
Note: See TracChangeset for help on using the changeset viewer.