Subversion Repositories HelenOS

Rev

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

Rev 4206 Rev 4213
Line 41... Line 41...
41
#include <typedefs.h>
41
#include <typedefs.h>
42
#include <string.h>
42
#include <string.h>
43
 
43
 
44
SPINLOCK_INITIALIZE(printf_lock);  /**< vprintf spinlock */
44
SPINLOCK_INITIALIZE(printf_lock);  /**< vprintf spinlock */
45
 
45
 
46
static int vprintf_write_utf8(const char *str, size_t size, void *data)
46
static int vprintf_str_write(const char *str, size_t size, void *data)
47
{
47
{
48
    size_t offset = 0;
48
    size_t offset = 0;
49
    count_t chars = 0;
49
    count_t chars = 0;
50
 
50
   
51
    while (offset < size) {
51
    while (offset < size) {
52
        putchar(chr_decode(str, &offset, size));
52
        putchar(str_decode(str, &offset, size));
53
        chars++;
53
        chars++;
54
    }
54
    }
55
 
55
   
56
    return chars;
56
    return chars;
57
}
57
}
58
 
58
 
59
static int vprintf_write_utf32(const wchar_t *str, size_t size, void *data)
59
static int vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
60
{
60
{
61
    index_t index = 0;
61
    size_t offset = 0;
-
 
62
    count_t chars = 0;
62
 
63
   
63
    while (index < (size / sizeof(wchar_t))) {
64
    while (offset < size) {
64
        putchar(str[index]);
65
        putchar(str[chars]);
65
        index++;
66
        chars++;
-
 
67
        offset += sizeof(wchar_t);
66
    }
68
    }
67
 
69
   
68
    return index;
70
    return chars;
69
}
71
}
70
 
72
 
71
int puts(const char *str)
73
int puts(const char *str)
72
{
74
{
73
    size_t offset = 0;
75
    size_t offset = 0;
74
    count_t chars = 0;
76
    count_t chars = 0;
75
    wchar_t uc;
77
    wchar_t uc;
76
 
78
   
77
    while ((uc = chr_decode(str, &offset, UTF8_NO_LIMIT)) != 0) {
79
    while ((uc = str_decode(str, &offset, STR_NO_LIMIT)) != 0) {
78
        putchar(uc);
80
        putchar(uc);
79
        chars++;
81
        chars++;
80
    }
82
    }
81
 
83
   
82
    return chars;
84
    return chars;
83
}
85
}
84
 
86
 
85
int vprintf(const char *fmt, va_list ap)
87
int vprintf(const char *fmt, va_list ap)
86
{
88
{
87
    printf_spec_t ps = {
89
    printf_spec_t ps = {
88
        vprintf_write_utf8,
90
        vprintf_str_write,
89
        vprintf_write_utf32,
91
        vprintf_wstr_write,
90
        NULL
92
        NULL
91
    };
93
    };
92
 
94
   
93
    ipl_t ipl = interrupts_disable();
95
    ipl_t ipl = interrupts_disable();
94
    spinlock_lock(&printf_lock);
96
    spinlock_lock(&printf_lock);
95
 
97
   
96
    int ret = printf_core(fmt, &ps, ap);
98
    int ret = printf_core(fmt, &ps, ap);
97
 
99
   
98
    spinlock_unlock(&printf_lock);
100
    spinlock_unlock(&printf_lock);
99
    interrupts_restore(ipl);
101
    interrupts_restore(ipl);
100
 
102
   
101
    return ret;
103
    return ret;
102
}
104
}
103
 
105
 
104
/** @}
106
/** @}
105
 */
107
 */