Subversion Repositories HelenOS

Rev

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

Rev 4200 Rev 4206
Line 43... Line 43...
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_write_utf8(const char *str, size_t size, void *data)
47 
{
 47 
{
48 
    index_t index = 0;
 48 
    size_t offset = 0;
49 
    index_t chars = 0;
 49 
    count_t chars = 0;
50 
   
 50 
 
51 
    while (index < size) {
 51 
    while (offset < size) {
52 
        putchar(chr_decode(str, &index, size));
 52 
        putchar(chr_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_write_utf32(const wchar_t *str, size_t size, void *data)
60 
{
 60 
{
61 
    index_t index = 0;
 61 
    index_t index = 0;
62 
   
 62 
 
63 
    while (index < (size / sizeof(wchar_t))) {
 63 
    while (index < (size / sizeof(wchar_t))) {
64 
        putchar(str[index]);
 64 
        putchar(str[index]);
65 
        index++;
 65 
        index++;
66 
    }
 66 
    }
67 
   
 67 
 
68 
    return index;
 68 
    return index;
69 
}
 69 
}
70 
 
 70 
 
71 
int puts(const char *str)
 71 
int puts(const char *str)
72 
{
 72 
{
73 
    index_t index = 0;
 73 
    size_t offset = 0;
74 
    index_t chars = 0;
 74 
    count_t chars = 0;
75 
    wchar_t uc;
 75 
    wchar_t uc;
76 
   
 76 
 
77 
    while ((uc = chr_decode(str, &index, UTF8_NO_LIMIT)) != 0) {
 77 
    while ((uc = chr_decode(str, &offset, UTF8_NO_LIMIT)) != 0) {
78 
        putchar(uc);
 78 
        putchar(uc);
79 
        chars++;
 79 
        chars++;
80 
    }
 80 
    }
81 
   
 81 
 
82 
    return chars;
 82 
    return chars;
83 
}
 83 
}
84 
 
 84 
 
85 
int vprintf(const char *fmt, va_list ap)
 85 
int vprintf(const char *fmt, va_list ap)
86 
{
 86 
{
87 
    printf_spec_t ps = {
 87 
    printf_spec_t ps = {
88 
        vprintf_write_utf8,
 88 
        vprintf_write_utf8,
89 
        vprintf_write_utf32,
 89 
        vprintf_write_utf32,
90 
        NULL
 90 
        NULL
91 
    };
 91 
    };
92 
   
 92 
 
93 
    ipl_t ipl = interrupts_disable();
 93 
    ipl_t ipl = interrupts_disable();
94 
    spinlock_lock(&printf_lock);
 94 
    spinlock_lock(&printf_lock);
95 
   
 95 
 
96 
    int ret = printf_core(fmt, &ps, ap);
 96 
    int ret = printf_core(fmt, &ps, ap);
97 
   
 97 
 
98 
    spinlock_unlock(&printf_lock);
 98 
    spinlock_unlock(&printf_lock);
99 
    interrupts_restore(ipl);
 99 
    interrupts_restore(ipl);
100 
   
 100 
 
101 
    return ret;
 101 
    return ret;
102 
}
 102 
}
103 
 
 103 
 
104 
/** @}
 104 
/** @}
105 
 */
 105 
 */