Subversion Repositories HelenOS

Rev

Rev 4206 | Rev 4213 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4206 Rev 4208
1
/*
1
/*
2
 * Copyright (c) 2006 Josef Cejka
2
 * Copyright (c) 2006 Josef Cejka
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/** @addtogroup generic
29
/** @addtogroup generic
30
 * @{
30
 * @{
31
 */
31
 */
32
/** @file
32
/** @file
33
 */
33
 */
34
 
34
 
35
#include <print.h>
35
#include <print.h>
36
#include <printf/printf_core.h>
36
#include <printf/printf_core.h>
37
#include <string.h>
37
#include <string.h>
38
#include <memstr.h>
38
#include <memstr.h>
-
 
39
#include <errno.h>
39
 
40
 
40
typedef struct {
41
typedef struct {
41
    size_t size;    /* Total size of the buffer (in bytes) */
42
    size_t size;    /* Total size of the buffer (in bytes) */
42
    size_t len;     /* Number of already used bytes */
43
    size_t len;     /* Number of already used bytes */
43
    char *dst;      /* Destination */
44
    char *dst;      /* Destination */
44
} vsnprintf_data_t;
45
} vsnprintf_data_t;
45
 
46
 
46
/** Write UTF-8 string to given buffer.
47
/** Write UTF-8 string to given buffer.
47
 *
48
 *
48
 * Write at most data->size plain characters including trailing zero.
49
 * Write at most data->size plain characters including trailing zero.
49
 * According to C99, snprintf() has to return number of characters that
50
 * According to C99, snprintf() has to return number of characters that
50
 * would have been written if enough space had been available. Hence
51
 * would have been written if enough space had been available. Hence
51
 * the return value is not the number of actually printed characters
52
 * the return value is not the number of actually printed characters
52
 * but size of the input string.
53
 * but size of the input string.
53
 *
54
 *
54
 * @param str  Source UTF-8 string to print.
55
 * @param str  Source UTF-8 string to print.
55
 * @param size Number of plain characters in str.
56
 * @param size Number of plain characters in str.
56
 * @param data Structure describing destination string, counter
57
 * @param data Structure describing destination string, counter
57
 *             of used space and total string size.
58
 *             of used space and total string size.
58
 *
59
 *
59
 * @return Number of UTF-8 characters to print (not characters actually
60
 * @return Number of UTF-8 characters to print (not characters actually
60
 *         printed).
61
 *         printed).
61
 *
62
 *
62
 */
63
 */
63
static int vsnprintf_write_utf8(const char *str, size_t size, vsnprintf_data_t *data)
64
static int vsnprintf_write_utf8(const char *str, size_t size, vsnprintf_data_t *data)
64
{
65
{
65
    size_t left = data->size - data->len;
66
    size_t left = data->size - data->len;
66
   
67
   
67
    if (left == 0)
68
    if (left == 0)
68
        return ((int) size);
69
        return ((int) size);
69
   
70
   
70
    if (left == 1) {
71
    if (left == 1) {
71
        /* We have only one free byte left in buffer
72
        /* We have only one free byte left in buffer
72
         * -> store trailing zero
73
         * -> store trailing zero
73
         */
74
         */
74
        data->dst[data->size - 1] = 0;
75
        data->dst[data->size - 1] = 0;
75
        data->len = data->size;
76
        data->len = data->size;
76
        return ((int) size);
77
        return ((int) size);
77
    }
78
    }
78
   
79
   
79
    if (left <= size) {
80
    if (left <= size) {
80
        /* We do not have enough space for the whole string
81
        /* We do not have enough space for the whole string
81
         * with the trailing zero => print only a part
82
         * with the trailing zero => print only a part
82
         * of string
83
         * of string
83
         */
84
         */
84
        index_t index = 0;
85
        index_t index = 0;
85
       
86
       
86
        while (index < size) {
87
        while (index < size) {
87
            wchar_t uc = chr_decode(str, &index, size);
88
            wchar_t uc = chr_decode(str, &index, size);
88
 
89
 
89
            if (!chr_encode(uc, data->dst, &data->len, data->size - 1))
90
            if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK)
90
                break;
91
                break;
91
        }
92
        }
92
       
93
       
93
        /* Put trailing zero at end, but not count it
94
        /* Put trailing zero at end, but not count it
94
         * into data->len so it could be rewritten next time
95
         * into data->len so it could be rewritten next time
95
         */
96
         */
96
        data->dst[data->len] = 0;
97
        data->dst[data->len] = 0;
97
       
98
       
98
        return ((int) size);
99
        return ((int) size);
99
    }
100
    }
100
   
101
   
101
    /* Buffer is big enought to print the whole string */
102
    /* Buffer is big enought to print the whole string */
102
    memcpy((void *)(data->dst + data->len), (void *) str, size);
103
    memcpy((void *)(data->dst + data->len), (void *) str, size);
103
    data->len += size;
104
    data->len += size;
104
   
105
   
105
    /* Put trailing zero at end, but not count it
106
    /* Put trailing zero at end, but not count it
106
     * into data->len so it could be rewritten next time
107
     * into data->len so it could be rewritten next time
107
     */
108
     */
108
    data->dst[data->len] = 0;
109
    data->dst[data->len] = 0;
109
   
110
   
110
    return ((int) size);
111
    return ((int) size);
111
}
112
}
112
 
113
 
113
/** Write UTF-32 string to given buffer.
114
/** Write UTF-32 string to given buffer.
114
 *
115
 *
115
 * Write at most data->size plain characters including trailing zero.
116
 * Write at most data->size plain characters including trailing zero.
116
 * According to C99, snprintf() has to return number of characters that
117
 * According to C99, snprintf() has to return number of characters that
117
 * would have been written if enough space had been available. Hence
118
 * would have been written if enough space had been available. Hence
118
 * the return value is not the number of actually printed characters
119
 * the return value is not the number of actually printed characters
119
 * but size of the input string.
120
 * but size of the input string.
120
 *
121
 *
121
 * @param str  Source UTF-32 string to print.
122
 * @param str  Source UTF-32 string to print.
122
 * @param size Number of bytes in str.
123
 * @param size Number of bytes in str.
123
 * @param data Structure describing destination string, counter
124
 * @param data Structure describing destination string, counter
124
 *             of used space and total string size.
125
 *             of used space and total string size.
125
 *
126
 *
126
 * @return Number of UTF-8 characters to print (not characters actually
127
 * @return Number of UTF-8 characters to print (not characters actually
127
 *         printed).
128
 *         printed).
128
 *
129
 *
129
 */
130
 */
130
static int vsnprintf_write_utf32(const wchar_t *str, size_t size, vsnprintf_data_t *data)
131
static int vsnprintf_write_utf32(const wchar_t *str, size_t size, vsnprintf_data_t *data)
131
{
132
{
132
    index_t index = 0;
133
    index_t index = 0;
133
   
134
   
134
    while (index < (size / sizeof(wchar_t))) {
135
    while (index < (size / sizeof(wchar_t))) {
135
        size_t left = data->size - data->len;
136
        size_t left = data->size - data->len;
136
       
137
       
137
        if (left == 0)
138
        if (left == 0)
138
            return ((int) size);
139
            return ((int) size);
139
       
140
       
140
        if (left == 1) {
141
        if (left == 1) {
141
            /* We have only one free byte left in buffer
142
            /* We have only one free byte left in buffer
142
             * -> store trailing zero
143
             * -> store trailing zero
143
             */
144
             */
144
            data->dst[data->size - 1] = 0;
145
            data->dst[data->size - 1] = 0;
145
            data->len = data->size;
146
            data->len = data->size;
146
            return ((int) size);
147
            return ((int) size);
147
        }
148
        }
148
       
149
       
149
        if (!chr_encode(str[index], data->dst, &data->len, data->size - 1))
150
        if (chr_encode(str[index], data->dst, &data->len, data->size - 1) != EOK)
150
            break;
151
            break;
151
       
152
       
152
        index++;
153
        index++;
153
    }
154
    }
154
   
155
   
155
    /* Put trailing zero at end, but not count it
156
    /* Put trailing zero at end, but not count it
156
     * into data->len so it could be rewritten next time
157
     * into data->len so it could be rewritten next time
157
     */
158
     */
158
    data->dst[data->len] = 0;
159
    data->dst[data->len] = 0;
159
   
160
   
160
    return ((int) size);
161
    return ((int) size);
161
}
162
}
162
 
163
 
163
int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
164
int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
164
{
165
{
165
    vsnprintf_data_t data = {
166
    vsnprintf_data_t data = {
166
        size,
167
        size,
167
        0,
168
        0,
168
        str
169
        str
169
    };
170
    };
170
    printf_spec_t ps = {
171
    printf_spec_t ps = {
171
        (int(*) (const char *, size_t, void *)) vsnprintf_write_utf8,
172
        (int(*) (const char *, size_t, void *)) vsnprintf_write_utf8,
172
        (int(*) (const wchar_t *, size_t, void *)) vsnprintf_write_utf32,
173
        (int(*) (const wchar_t *, size_t, void *)) vsnprintf_write_utf32,
173
        &data
174
        &data
174
    };
175
    };
175
   
176
   
176
    /* Print 0 at end of string - fix the case that nothing will be printed */
177
    /* Print 0 at end of string - fix the case that nothing will be printed */
177
    if (size > 0)
178
    if (size > 0)
178
        str[0] = 0;
179
        str[0] = 0;
179
   
180
   
180
    /* vsnprintf_write ensures that str will be terminated by zero. */
181
    /* vsnprintf_write ensures that str will be terminated by zero. */
181
    return printf_core(fmt, &ps, ap);
182
    return printf_core(fmt, &ps, ap);
182
}
183
}
183
 
184
 
184
/** @}
185
/** @}
185
 */
186
 */
186
 
187