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 
 */