Subversion Repositories HelenOS

Rev

Rev 4312 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4312 Rev 4472
Line 241... Line 241...
241
 * @param max_len Maximum number of characters to measure.
241
 * @param max_len Maximum number of characters to measure.
242
 *
242
 *
243
 * @return Number of bytes used by the characters.
243
 * @return Number of bytes used by the characters.
244
 *
244
 *
245
 */
245
 */
246
size_t str_lsize(const char *str, count_t max_len)
246
size_t str_lsize(const char *str, size_t max_len)
247
{
247
{
248
    count_t len = 0;
248
    size_t len = 0;
249
    size_t offset = 0;
249
    size_t offset = 0;
250
   
250
   
251
    while (len < max_len) {
251
    while (len < max_len) {
252
        if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
252
        if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
253
            break;
253
            break;
Line 269... Line 269...
269
 * @param max_len Maximum number of wide characters to measure.
269
 * @param max_len Maximum number of wide characters to measure.
270
 *
270
 *
271
 * @return Number of bytes used by the wide characters.
271
 * @return Number of bytes used by the wide characters.
272
 *
272
 *
273
 */
273
 */
274
size_t wstr_lsize(const wchar_t *str, count_t max_len)
274
size_t wstr_lsize(const wchar_t *str, size_t max_len)
275
{
275
{
276
    return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
276
    return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
277
}
277
}
278
 
278
 
279
/** Get number of characters in a string.
279
/** Get number of characters in a string.
Line 281... Line 281...
281
 * @param str NULL-terminated string.
281
 * @param str NULL-terminated string.
282
 *
282
 *
283
 * @return Number of characters in string.
283
 * @return Number of characters in string.
284
 *
284
 *
285
 */
285
 */
286
count_t str_length(const char *str)
286
size_t str_length(const char *str)
287
{
287
{
288
    count_t len = 0;
288
    size_t len = 0;
289
    size_t offset = 0;
289
    size_t offset = 0;
290
   
290
   
291
    while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
291
    while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
292
        len++;
292
        len++;
293
   
293
   
Line 299... Line 299...
299
 * @param str NULL-terminated wide string.
299
 * @param str NULL-terminated wide string.
300
 *
300
 *
301
 * @return Number of characters in @a str.
301
 * @return Number of characters in @a str.
302
 *
302
 *
303
 */
303
 */
304
count_t wstr_length(const wchar_t *wstr)
304
size_t wstr_length(const wchar_t *wstr)
305
{
305
{
306
    count_t len = 0;
306
    size_t len = 0;
307
   
307
   
308
    while (*wstr++ != 0)
308
    while (*wstr++ != 0)
309
        len++;
309
        len++;
310
   
310
   
311
    return len;
311
    return len;
Line 317... Line 317...
317
 * @param size Maximum number of bytes to consider.
317
 * @param size Maximum number of bytes to consider.
318
 *
318
 *
319
 * @return Number of characters in string.
319
 * @return Number of characters in string.
320
 *
320
 *
321
 */
321
 */
322
count_t str_nlength(const char *str, size_t size)
322
size_t str_nlength(const char *str, size_t size)
323
{
323
{
324
    count_t len = 0;
324
    size_t len = 0;
325
    size_t offset = 0;
325
    size_t offset = 0;
326
   
326
   
327
    while (str_decode(str, &offset, size) != 0)
327
    while (str_decode(str, &offset, size) != 0)
328
        len++;
328
        len++;
329
   
329
   
Line 336... Line 336...
336
 * @param size Maximum number of bytes to consider.
336
 * @param size Maximum number of bytes to consider.
337
 *
337
 *
338
 * @return Number of characters in string.
338
 * @return Number of characters in string.
339
 *
339
 *
340
 */
340
 */
341
count_t wstr_nlength(const wchar_t *str, size_t size)
341
size_t wstr_nlength(const wchar_t *str, size_t size)
342
{
342
{
343
    count_t len = 0;
343
    size_t len = 0;
344
    count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
344
    size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
345
    count_t offset = 0;
345
    size_t offset = 0;
346
   
346
   
347
    while ((offset < limit) && (*str++ != 0)) {
347
    while ((offset < limit) && (*str++ != 0)) {
348
        len++;
348
        len++;
349
        offset += sizeof(wchar_t);
349
        offset += sizeof(wchar_t);
350
    }
350
    }
Line 428... Line 428...
428
 *
428
 *
429
 * @return 0 if the strings are equal, -1 if first is smaller,
429
 * @return 0 if the strings are equal, -1 if first is smaller,
430
 *         1 if second smaller.
430
 *         1 if second smaller.
431
 *
431
 *
432
 */
432
 */
433
int str_lcmp(const char *s1, const char *s2, count_t max_len)
433
int str_lcmp(const char *s1, const char *s2, size_t max_len)
434
{
434
{
435
    wchar_t c1 = 0;
435
    wchar_t c1 = 0;
436
    wchar_t c2 = 0;
436
    wchar_t c2 = 0;
437
   
437
   
438
    size_t off1 = 0;
438
    size_t off1 = 0;
439
    size_t off2 = 0;
439
    size_t off2 = 0;
440
   
440
   
441
    count_t len = 0;
441
    size_t len = 0;
442
 
442
 
443
    while (true) {
443
    while (true) {
444
        if (len >= max_len)
444
        if (len >= max_len)
445
            break;
445
            break;
446
 
446
 
Line 566... Line 566...
566
    /* No space for the NULL-terminator in the buffer */
566
    /* No space for the NULL-terminator in the buffer */
567
    if (size == 0)
567
    if (size == 0)
568
        return;
568
        return;
569
   
569
   
570
    wchar_t ch;
570
    wchar_t ch;
571
    count_t src_idx = 0;
571
    size_t src_idx = 0;
572
    size_t dst_off = 0;
572
    size_t dst_off = 0;
573
   
573
   
574
    while ((ch = src[src_idx++]) != 0) {
574
    while ((ch = src[src_idx++]) != 0) {
575
        if (chr_encode(ch, dst, &dst_off, size) != EOK)
575
        if (chr_encode(ch, dst, &dst_off, size) != EOK)
576
            break;
576
            break;
Line 614... Line 614...
614
const char *str_rchr(const char *str, wchar_t ch)
614
const char *str_rchr(const char *str, wchar_t ch)
615
{
615
{
616
    wchar_t acc;
616
    wchar_t acc;
617
    size_t off = 0;
617
    size_t off = 0;
618
    size_t last = 0;
618
    size_t last = 0;
619
    char *res = NULL;
619
    const char *res = NULL;
620
   
620
   
621
    while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
621
    while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
622
        if (acc == ch)
622
        if (acc == ch)
623
            res = (str + last);
623
            res = (str + last);
624
        last = off;
624
        last = off;
Line 639... Line 639...
639
 *
639
 *
640
 * @return True if the insertion was sucessful, false if the position
640
 * @return True if the insertion was sucessful, false if the position
641
 *         is out of bounds.
641
 *         is out of bounds.
642
 *
642
 *
643
 */
643
 */
644
bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos)
644
bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
645
{
645
{
646
    count_t len = wstr_length(str);
646
    size_t len = wstr_length(str);
647
   
647
   
648
    if ((pos > len) || (pos + 1 > max_pos))
648
    if ((pos > len) || (pos + 1 > max_pos))
649
        return false;
649
        return false;
650
   
650
   
651
    count_t i;
651
    size_t i;
652
    for (i = len; i + 1 > pos; i--)
652
    for (i = len; i + 1 > pos; i--)
653
        str[i + 1] = str[i];
653
        str[i + 1] = str[i];
654
   
654
   
655
    str[pos] = ch;
655
    str[pos] = ch;
656
   
656
   
Line 667... Line 667...
667
 *
667
 *
668
 * @return True if the removal was sucessful, false if the position
668
 * @return True if the removal was sucessful, false if the position
669
 *         is out of bounds.
669
 *         is out of bounds.
670
 *
670
 *
671
 */
671
 */
672
bool wstr_remove(wchar_t *str, count_t pos)
672
bool wstr_remove(wchar_t *str, size_t pos)
673
{
673
{
674
    count_t len = wstr_length(str);
674
    size_t len = wstr_length(str);
675
   
675
   
676
    if (pos >= len)
676
    if (pos >= len)
677
        return false;
677
        return false;
678
   
678
   
679
    count_t i;
679
    size_t i;
680
    for (i = pos + 1; i <= len; i++)
680
    for (i = pos + 1; i <= len; i++)
681
        str[i - 1] = str[i];
681
        str[i - 1] = str[i];
682
   
682
   
683
    return true;
683
    return true;
684
}
684
}