Bug Summary

File:src/xlibi18n/lcConv.c
Location:line 259, column 22
Description:Result of 'calloc' is converted to a pointer of type 'char', which is incompatible with sizeof operand type 'ConvRec'

Annotated Source Code

1/*
2 * Copyright 1992, 1993 by TOSHIBA Corp.
3 *
4 * Permission to use, copy, modify, and distribute this software and its
5 * documentation for any purpose and without fee is hereby granted, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of TOSHIBA not be used in advertising
9 * or publicity pertaining to distribution of the software without specific,
10 * written prior permission. TOSHIBA make no representations about the
11 * suitability of this software for any purpose. It is provided "as is"
12 * without express or implied warranty.
13 *
14 * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
15 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
16 * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
17 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
18 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
19 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
20 * SOFTWARE.
21 *
22 * Author: Katsuhisa Yano TOSHIBA Corp.
23 * mopi@osa.ilab.toshiba.co.jp
24 */
25
26#ifdef HAVE_CONFIG_H1
27#include <config.h>
28#endif
29#include "Xlibint.h"
30#include "XlcPubI.h"
31#include <stdio.h>
32
33typedef struct _XlcConverterListRec {
34 XLCd from_lcd;
35 const char *from;
36 XrmQuark from_type;
37 XLCd to_lcd;
38 const char *to;
39 XrmQuark to_type;
40 XlcOpenConverterProc converter;
41 struct _XlcConverterListRec *next;
42} XlcConverterListRec, *XlcConverterList;
43
44static XlcConverterList conv_list = NULL((void*)0);
45
46static void
47close_converter(
48 XlcConv conv)
49{
50 (*conv->methods->close)(conv);
51}
52
53static XlcConv
54get_converter(
55 XLCd from_lcd,
56 XrmQuark from_type,
57 XLCd to_lcd,
58 XrmQuark to_type)
59{
60 XlcConverterList list, prev = NULL((void*)0);
61
62 for (list = conv_list; list; list = list->next) {
63 if (list->from_lcd == from_lcd && list->to_lcd == to_lcd
64 && list->from_type == from_type && list->to_type == to_type) {
65
66 if (prev && prev != conv_list) { /* XXX */
67 prev->next = list->next;
68 list->next = conv_list;
69 conv_list = list;
70 }
71
72 return (*list->converter)(from_lcd, list->from, to_lcd, list->to);
73 }
74
75 prev = list;
76 }
77
78 return (XlcConv) NULL((void*)0);
79}
80
81Boolint
82_XlcSetConverter(
83 XLCd from_lcd,
84 const char *from,
85 XLCd to_lcd,
86 const char *to,
87 XlcOpenConverterProc converter)
88{
89 XlcConverterList list;
90 XrmQuark from_type, to_type;
91
92 from_type = XrmStringToQuark(from);
93 to_type = XrmStringToQuark(to);
94
95 for (list = conv_list; list; list = list->next) {
96 if (list->from_lcd == from_lcd && list->to_lcd == to_lcd
97 && list->from_type == from_type && list->to_type == to_type) {
98
99 list->converter = converter;
100 return True1;
101 }
102 }
103
104 list = Xmalloc(sizeof(XlcConverterListRec))malloc(((sizeof(XlcConverterListRec)) == 0 ? 1 : (sizeof(XlcConverterListRec
))))
;
105 if (list == NULL((void*)0))
106 return False0;
107
108 list->from_lcd = from_lcd;
109 list->from = from;
110 list->from_type = from_type;
111 list->to_lcd = to_lcd;
112 list->to = to;
113 list->to_type = to_type;
114 list->converter = converter;
115 list->next = conv_list;
116 conv_list = list;
117
118 return True1;
119}
120
121typedef struct _ConvRec {
122 XlcConv from_conv;
123 XlcConv to_conv;
124} ConvRec, *Conv;
125
126static int
127indirect_convert(
128 XlcConv lc_conv,
129 XPointer *from,
130 int *from_left,
131 XPointer *to,
132 int *to_left,
133 XPointer *args,
134 int num_args)
135{
136 Conv conv = (Conv) lc_conv->state;
137 XlcConv from_conv = conv->from_conv;
138 XlcConv to_conv = conv->to_conv;
139 XlcCharSet charset;
140 char buf[BUFSIZ1024], *cs;
141 XPointer tmp_args[1];
142 int cs_left, ret, length, unconv_num = 0;
143
144 if (from == NULL((void*)0) || *from == NULL((void*)0)) {
145 if (from_conv->methods->reset)
146 (*from_conv->methods->reset)(from_conv);
147
148 if (to_conv->methods->reset)
149 (*to_conv->methods->reset)(to_conv);
150
151 return 0;
152 }
153
154 while (*from_left > 0) {
155 cs = buf;
156 cs_left = BUFSIZ1024;
157 tmp_args[0] = (XPointer) &charset;
158
159 ret = (*from_conv->methods->convert)(from_conv, from, from_left, &cs,
160 &cs_left, tmp_args, 1);
161 if (ret < 0)
162 break;
163
164 unconv_num += ret;
165
166 length = cs - buf;
167 if (length > 0) {
168 cs_left = length;
169 cs = buf;
170
171 tmp_args[0] = (XPointer) charset;
172
173 ret = (*to_conv->methods->convert)(to_conv, &cs, &cs_left, to, to_left,
174 tmp_args, 1);
175 if (ret < 0) {
176 unconv_num += length / (charset->char_size > 0 ? charset->char_size : 1);
177 continue;
178 }
179
180 unconv_num += ret;
181
182 if (*to_left < 1)
183 break;
184 }
185 }
186
187 return unconv_num;
188}
189
190static void
191close_indirect_converter(
192 XlcConv lc_conv)
193{
194 Conv conv = (Conv) lc_conv->state;
195
196 if (conv) {
197 if (conv->from_conv)
198 close_converter(conv->from_conv);
199 if (conv->to_conv)
200 close_converter(conv->to_conv);
201
202 Xfree(conv)free((conv));
203 }
204
205 Xfree(lc_conv)free((lc_conv));
206}
207
208static void
209reset_indirect_converter(
210 XlcConv lc_conv)
211{
212 Conv conv = (Conv) lc_conv->state;
213
214 if (conv) {
215 if (conv->from_conv && conv->from_conv->methods->reset)
216 (*conv->from_conv->methods->reset)(conv->from_conv);
217 if (conv->to_conv && conv->to_conv->methods->reset)
218 (*conv->to_conv->methods->reset)(conv->to_conv);
219 }
220}
221
222static XlcConvMethodsRec conv_methods = {
223 close_indirect_converter,
224 indirect_convert,
225 reset_indirect_converter
226} ;
227
228static XlcConv
229open_indirect_converter(
230 XLCd from_lcd,
231 const char *from,
232 XLCd to_lcd,
233 const char *to)
234{
235 XlcConv lc_conv, from_conv, to_conv;
236 Conv conv;
237 XrmQuark from_type, to_type;
238 static XrmQuark QChar, QCharSet, QCTCharSet = (XrmQuark) 0;
239
240 if (QCTCharSet == (XrmQuark) 0) {
241 QCTCharSet = XrmStringToQuark(XlcNCTCharSet"CTcharSet");
242 QCharSet = XrmStringToQuark(XlcNCharSet"charSet");
243 QChar = XrmStringToQuark(XlcNChar"char");
244 }
245
246 from_type = XrmStringToQuark(from);
247 to_type = XrmStringToQuark(to);
248
249 if (from_type == QCharSet || from_type == QChar || to_type == QCharSet ||
250 to_type == QChar)
251 return (XlcConv) NULL((void*)0);
252
253 lc_conv = Xmalloc(sizeof(XlcConvRec))malloc(((sizeof(XlcConvRec)) == 0 ? 1 : (sizeof(XlcConvRec)))
)
;
254 if (lc_conv == NULL((void*)0))
255 return (XlcConv) NULL((void*)0);
256
257 lc_conv->methods = &conv_methods;
258
259 lc_conv->state = Xcalloc(1, sizeof(ConvRec))calloc(((1) == 0 ? 1 : (1)), (sizeof(ConvRec)));
Result of 'calloc' is converted to a pointer of type 'char', which is incompatible with sizeof operand type 'ConvRec'
260 if (lc_conv->state == NULL((void*)0))
261 goto err;
262
263 conv = (Conv) lc_conv->state;
264
265 from_conv = get_converter(from_lcd, from_type, from_lcd, QCTCharSet);
266 if (from_conv == NULL((void*)0))
267 from_conv = get_converter(from_lcd, from_type, from_lcd, QCharSet);
268 if (from_conv == NULL((void*)0))
269 from_conv = get_converter((XLCd)NULL((void*)0), from_type, (XLCd)NULL((void*)0), QCharSet);
270 if (from_conv == NULL((void*)0))
271 from_conv = get_converter(from_lcd, from_type, from_lcd, QChar);
272 if (from_conv == NULL((void*)0))
273 goto err;
274 conv->from_conv = from_conv;
275
276 to_conv = get_converter(to_lcd, QCTCharSet, to_lcd, to_type);
277 if (to_conv == NULL((void*)0))
278 to_conv = get_converter(to_lcd, QCharSet, to_lcd, to_type);
279 if (to_conv == NULL((void*)0))
280 to_conv = get_converter((XLCd) NULL((void*)0), QCharSet, (XLCd) NULL((void*)0), to_type);
281 if (to_conv == NULL((void*)0))
282 goto err;
283 conv->to_conv = to_conv;
284
285 return lc_conv;
286
287err:
288 close_indirect_converter(lc_conv);
289
290 return (XlcConv) NULL((void*)0);
291}
292
293XlcConv
294_XlcOpenConverter(
295 XLCd from_lcd,
296 const char *from,
297 XLCd to_lcd,
298 const char *to)
299{
300 XlcConv conv;
301 XrmQuark from_type, to_type;
302
303 from_type = XrmStringToQuark(from);
304 to_type = XrmStringToQuark(to);
305
306 if ((conv = get_converter(from_lcd, from_type, to_lcd, to_type)))
307 return conv;
308
309 return open_indirect_converter(from_lcd, from, to_lcd, to);
310}
311
312void
313_XlcCloseConverter(
314 XlcConv conv)
315{
316 close_converter(conv);
317}
318
319int
320_XlcConvert(
321 XlcConv conv,
322 XPointer *from,
323 int *from_left,
324 XPointer *to,
325 int *to_left,
326 XPointer *args,
327 int num_args)
328{
329 return (*conv->methods->convert)(conv, from, from_left, to, to_left, args,
330 num_args);
331}
332
333void
334_XlcResetConverter(
335 XlcConv conv)
336{
337 if (conv->methods->reset)
338 (*conv->methods->reset)(conv);
339}