Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/str.c

    r1558d85 ra18a8b9  
    4545#include <align.h>
    4646#include <mem.h>
     47#include <str.h>
    4748
    4849/** Check the condition if wchar_t is signed */
     
    518519        wchar_t c1 = 0;
    519520        wchar_t c2 = 0;
    520 
     521       
    521522        size_t off1 = 0;
    522523        size_t off2 = 0;
     
    528529                if (c1 < c2)
    529530                        return -1;
    530 
     531               
    531532                if (c1 > c2)
    532533                        return 1;
     
    565566        wchar_t c1 = 0;
    566567        wchar_t c2 = 0;
    567 
     568       
    568569        size_t off1 = 0;
    569570        size_t off2 = 0;
    570 
     571       
    571572        size_t len = 0;
    572573
     
    588589
    589590                ++len;
    590         }
    591 
    592         return 0;
    593 
    594 }
    595 
    596 /** Compare two NULL terminated strings in case-insensitive manner.
    597  *
    598  * Do a char-by-char comparison of two NULL-terminated strings.
    599  * The strings are considered equal iff their length is equal
    600  * and both strings consist of the same sequence of characters
    601  * when converted to lower case.
    602  *
    603  * A string S1 is less than another string S2 if it has a character with
    604  * lower value at the first character position where the strings differ.
    605  * If the strings differ in length, the shorter one is treated as if
    606  * padded by characters with a value of zero.
    607  *
    608  * @param s1 First string to compare.
    609  * @param s2 Second string to compare.
    610  *
    611  * @return 0 if the strings are equal, -1 if the first is less than the second,
    612  *         1 if the second is less than the first.
    613  *
    614  */
    615 int str_casecmp(const char *s1, const char *s2)
    616 {
    617         wchar_t c1 = 0;
    618         wchar_t c2 = 0;
    619 
    620         size_t off1 = 0;
    621         size_t off2 = 0;
    622 
    623         while (true) {
    624                 c1 = tolower(str_decode(s1, &off1, STR_NO_LIMIT));
    625                 c2 = tolower(str_decode(s2, &off2, STR_NO_LIMIT));
    626 
    627                 if (c1 < c2)
    628                         return -1;
    629 
    630                 if (c1 > c2)
    631                         return 1;
    632 
    633                 if (c1 == 0 || c2 == 0)
    634                         break;
    635         }
    636 
    637         return 0;
    638 }
    639 
    640 /** Compare two NULL terminated strings with length limit in case-insensitive
    641  * manner.
    642  *
    643  * Do a char-by-char comparison of two NULL-terminated strings.
    644  * The strings are considered equal iff
    645  * min(str_length(s1), max_len) == min(str_length(s2), max_len)
    646  * and both strings consist of the same sequence of characters,
    647  * up to max_len characters.
    648  *
    649  * A string S1 is less than another string S2 if it has a character with
    650  * lower value at the first character position where the strings differ.
    651  * If the strings differ in length, the shorter one is treated as if
    652  * padded by characters with a value of zero. Only the first max_len
    653  * characters are considered.
    654  *
    655  * @param s1      First string to compare.
    656  * @param s2      Second string to compare.
    657  * @param max_len Maximum number of characters to consider.
    658  *
    659  * @return 0 if the strings are equal, -1 if the first is less than the second,
    660  *         1 if the second is less than the first.
    661  *
    662  */
    663 int str_lcasecmp(const char *s1, const char *s2, size_t max_len)
    664 {
    665         wchar_t c1 = 0;
    666         wchar_t c2 = 0;
    667        
    668         size_t off1 = 0;
    669         size_t off2 = 0;
    670        
    671         size_t len = 0;
    672 
    673         while (true) {
    674                 if (len >= max_len)
    675                         break;
    676 
    677                 c1 = tolower(str_decode(s1, &off1, STR_NO_LIMIT));
    678                 c2 = tolower(str_decode(s2, &off2, STR_NO_LIMIT));
    679 
    680                 if (c1 < c2)
    681                         return -1;
    682 
    683                 if (c1 > c2)
    684                         return 1;
    685 
    686                 if (c1 == 0 || c2 == 0)
    687                         break;
    688 
    689                 ++len; 
    690591        }
    691592
     
    11571058                memmove(str, &str[pos], str_sz - pos);
    11581059                pos = str_sz - pos;
    1159                 str[str_sz - pos] = '\0';
     1060                str[pos] = '\0';
    11601061        }
    11611062}
     
    12501151}
    12511152
    1252 /** Convert string to a number. 
     1153/** Convert string to a number.
    12531154 * Core of strtol and strtoul functions.
    12541155 *
     
    12961197                                str += 2;
    12971198                        }
    1298                 } 
     1199                }
    12991200        }
    13001201       
     
    13351236                *endptr = (char *) str;
    13361237
    1337         if (nptr == str) { 
     1238        if (nptr == str) {
    13381239                /*FIXME: errno = EINVAL*/
    13391240                return 0;
     
    13661267                if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {
    13671268                        /* FIXME: set 0 to errno */
    1368                         return number;         
     1269                        return number;
    13691270                }
    13701271                /* FIXME: set ERANGE to errno */
    1371                 return (sgn ? LONG_MIN : LONG_MAX);     
     1272                return (sgn ? LONG_MIN : LONG_MAX);
    13721273        }
    13731274       
Note: See TracChangeset for help on using the changeset viewer.