1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
#include <gu/write.h>
size_t
gu_utf32_write(const GuUCS* src, size_t len, GuWriter* wtr, GuExn* err)
{
return gu_utf32_out_utf8(src, len, &wtr->out_, err);
}
void
gu_vprintf(const char* fmt, va_list args, GuWriter* wtr, GuExn* err)
{
GuPool* tmp_pool = gu_local_pool();
char* str = gu_vasprintf(fmt, args, tmp_pool);
gu_puts(str, wtr, err);
gu_pool_free(tmp_pool);
}
void
gu_printf(GuWriter* wtr, GuExn* err, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
gu_vprintf(fmt, args, wtr, err);
va_end(args);
}
GuWriter*
gu_new_utf8_writer(GuOut* utf8_out, GuPool* pool)
{
GuOutStream* stream = gu_out_proxy_stream(utf8_out, pool);
GuWriter* wtr = gu_new(GuWriter, pool);
wtr->out_ = gu_init_out(stream);
return wtr;
}
#if 0
#ifdef GU_UCS_WCHAR
#include <stdlib.h>
#include <wchar.h>
static const mbstate_t gu_init_mbstate; // implicitly initialized to zero
#endif
typedef struct GuLocaleWriter GuLocaleWriter;
struct GuLocaleWriter {
GuOutWriter owtr;
#ifdef GU_UCS_WCHAR
mbstate_t ps;
size_t mb_cur_max;
#endif
};
size_t
gu_locale_writer_write(GuWriter* wtr, const uint8_t* utf8_src, size_t sz,
GuExn* err)
{
GuLocaleWriter* lwtr = (GuLocaleWriter*) wtr;
size_t done = 0;
static const size_t bufsize = 256;
#ifdef GU_UCS_WCHAR
size_t margin = lwtr->mb_cur_max;
#else
size_t margin = 1;
#endif
GuOut* out = lwtr->owtr.out;
if (gu_out_is_buffered(out)) {
while (done < sz) {
size_t dst_sz;
uint8_t* dst = gu_out_begin_span(out, &dst_sz);
if (!dst) {
break;
}
if (dst_sz <= margin) {
gu_out_end_span(out, 0);
break;
}
size_t end = dst_sz - margin;
const uint8_t*
size_t n = done;
while (n < sz && dst_i <= end) {
#ifdef GU_UCS_WCHAR
GuUCS ucs = gu_
wchar_t wc = src[n];
size_t nb = wcrtomb((char*) p, wc, &lwtr->ps);
#else
*p = (uint8_t) gu_ucs_char(buf[n], err);
size_t nb = 1;
if (!gu_ok(err)) {
gu_exn_clear(err);
nb = (size_t) -1;
}
#endif
if (nb == (size_t) -1) {
*p++ = (uint8_t) '?';
} else {
p += nb;
}
}
for (
}
}
uint8_t cbuf[256];
while (done < size && gu_ok(err)) {
uint8_t* p = cbuf;
uint8_t* edge = &cbuf[bufsize - margin];
size_t n;
for (n = done; p <= edge && n < size; n++) {
#ifdef GU_UCS_WCHAR
wchar_t wc = buf[n];
size_t nb = wcrtomb((char*) p, wc, &lwtr->ps);
#else
*p = (uint8_t) gu_ucs_char(buf[n], err);
size_t nb = 1;
if (!gu_ok(err)) {
gu_exn_clear(err);
nb = (size_t) -1;
}
#endif
if (nb == (size_t) -1) {
*p++ = (uint8_t) '?';
} else {
p += nb;
}
}
gu_out_bytes(lwtr->owtr.out, cbuf, p - cbuf, err);
if (gu_ok(err)) {
done = n;
}
}
return done;
}
GuWriter*
gu_locale_writer(GuOut* out, GuPool* pool)
{
GuLocaleWriter* lwtr = gu_new_s(
pool, GuLocaleWriter,
.wtr.out.output = gu_locale_writer_output,
.wtr.out.flush = gu_locale_writer_flush,
.out = out);
#ifdef GU_UCS_WCHAR
lwtr->ps = gu_init_mbstate;
lwtr->mb_cur_max = MB_CUR_MAX;
#endif
return (GuWriter*) lwtr;
}
#endif
extern inline void
gu_ucs_write(GuUCS ucs, GuWriter* wtr, GuExn* err);
extern inline void
gu_writer_flush(GuWriter* wtr, GuExn* err);
extern inline void
gu_putc(char c, GuWriter* wtr, GuExn* err);
extern inline void
gu_puts(const char* str, GuWriter* wtr, GuExn* err);
extern inline size_t
gu_utf8_write(const uint8_t* src, size_t sz, GuWriter* wtr, GuExn* err);
|
