1 /*
2  * "streamable kanji code filter and converter"
3  * Copyright (c) 1998-2002 HappySize, Inc. All rights reserved.
4  *
5  * LICENSE NOTICES
6  *
7  * This file is part of "streamable kanji code filter and converter",
8  * which is distributed under the terms of GNU Lesser General Public
9  * License (version 2) as published by the Free Software Foundation.
10  *
11  * This software is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with "streamable kanji code filter and converter";
18  * if not, write to the Free Software Foundation, Inc., 59 Temple Place,
19  * Suite 330, Boston, MA  02111-1307  USA
20  *
21  * The author of this file:
22  *
23  */
24 /*
25  * The source code included in this files was separated from mbfilter.c
26  * by Moriyoshi Koizumi <moriyoshi@php.net> on 20 Dec 2002. The file
27  * mbfilter.c is included in this package .
28  *
29  */
30 
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34 
35 #ifdef HAVE_STDDEF_H
36 #include <stddef.h>
37 #endif
38 
39 #include "mbfl_allocators.h"
40 #include "mbfl_string.h"
41 #include "mbfl_memory_device.h"
42 
43 /*
44  * memory device output functions
45  */
46 void
mbfl_memory_device_init(mbfl_memory_device * device,int initsz,int allocsz)47 mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz)
48 {
49 	if (device) {
50 		device->length = 0;
51 		device->buffer = (unsigned char *)0;
52 		if (initsz > 0) {
53 			device->buffer = (unsigned char *)mbfl_malloc(initsz*sizeof(unsigned char));
54 			if (device->buffer != NULL) {
55 				device->length = initsz;
56 			}
57 		}
58 		device->pos= 0;
59 		if (allocsz > MBFL_MEMORY_DEVICE_ALLOC_SIZE) {
60 			device->allocsz = allocsz;
61 		} else {
62 			device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
63 		}
64 	}
65 }
66 
67 void
mbfl_memory_device_realloc(mbfl_memory_device * device,int initsz,int allocsz)68 mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz)
69 {
70 	unsigned char *tmp;
71 
72 	if (device) {
73 		if (initsz > device->length) {
74 			tmp = (unsigned char *)mbfl_realloc((void *)device->buffer, initsz*sizeof(unsigned char));
75 			if (tmp != NULL) {
76 				device->buffer = tmp;
77 				device->length = initsz;
78 			}
79 		}
80 		if (allocsz > MBFL_MEMORY_DEVICE_ALLOC_SIZE) {
81 			device->allocsz = allocsz;
82 		} else {
83 			device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
84 		}
85 	}
86 }
87 
88 void
mbfl_memory_device_clear(mbfl_memory_device * device)89 mbfl_memory_device_clear(mbfl_memory_device *device)
90 {
91 	if (device) {
92 		if (device->buffer) {
93 			mbfl_free(device->buffer);
94 		}
95 		device->buffer = (unsigned char *)0;
96 		device->length = 0;
97 		device->pos = 0;
98 	}
99 }
100 
101 void
mbfl_memory_device_reset(mbfl_memory_device * device)102 mbfl_memory_device_reset(mbfl_memory_device *device)
103 {
104 	if (device) {
105 		device->pos = 0;
106 	}
107 }
108 
109 void
mbfl_memory_device_unput(mbfl_memory_device * device)110 mbfl_memory_device_unput(mbfl_memory_device *device)
111 {
112 	if (device->pos > 0) {
113 		device->pos--;
114 	}
115 }
116 
117 mbfl_string *
mbfl_memory_device_result(mbfl_memory_device * device,mbfl_string * result)118 mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result)
119 {
120 	if (device && result) {
121 		result->len = device->pos;
122 		mbfl_memory_device_output4('\0', device);
123 		result->val = device->buffer;
124 		device->buffer = (unsigned char *)0;
125 		device->length = 0;
126 		device->pos= 0;
127 		if (result->val == NULL) {
128 			result->len = 0;
129 			result = NULL;
130 		}
131 	} else {
132 		result = NULL;
133 	}
134 
135 	return result;
136 }
137 
138 int
mbfl_memory_device_output(int c,void * data)139 mbfl_memory_device_output(int c, void *data)
140 {
141 	mbfl_memory_device *device = (mbfl_memory_device *)data;
142 
143 	if (device->pos >= device->length) {
144 		/* reallocate buffer */
145 		int newlen;
146 		unsigned char *tmp;
147 
148 		newlen = device->length + device->allocsz;
149 		tmp = (unsigned char *)mbfl_realloc((void *)device->buffer, newlen*sizeof(unsigned char));
150 		if (tmp == NULL) {
151 			return -1;
152 		}
153 		device->length = newlen;
154 		device->buffer = tmp;
155 	}
156 
157 	device->buffer[device->pos++] = (unsigned char)c;
158 	return c;
159 }
160 
161 int
mbfl_memory_device_output2(int c,void * data)162 mbfl_memory_device_output2(int c, void *data)
163 {
164 	mbfl_memory_device *device = (mbfl_memory_device *)data;
165 
166 	if ((device->pos + 2) >= device->length) {
167 		/* reallocate buffer */
168 		int newlen;
169 		unsigned char *tmp;
170 
171 		newlen = device->length + device->allocsz;
172 		tmp = (unsigned char *)mbfl_realloc((void *)device->buffer, newlen*sizeof(unsigned char));
173 		if (tmp == NULL) {
174 			return -1;
175 		}
176 		device->length = newlen;
177 		device->buffer = tmp;
178 	}
179 
180 	device->buffer[device->pos++] = (unsigned char)((c >> 8) & 0xff);
181 	device->buffer[device->pos++] = (unsigned char)(c & 0xff);
182 
183 	return c;
184 }
185 
186 int
mbfl_memory_device_output4(int c,void * data)187 mbfl_memory_device_output4(int c, void* data)
188 {
189 	mbfl_memory_device *device = (mbfl_memory_device *)data;
190 
191 	if ((device->pos + 4) >= device->length) {
192 		/* reallocate buffer */
193 		int newlen;
194 		unsigned char *tmp;
195 
196 		newlen = device->length + device->allocsz;
197 		tmp = (unsigned char *)mbfl_realloc((void *)device->buffer, newlen*sizeof(unsigned char));
198 		if (tmp == NULL) {
199 			return -1;
200 		}
201 		device->length = newlen;
202 		device->buffer = tmp;
203 	}
204 
205 	device->buffer[device->pos++] = (unsigned char)((c >> 24) & 0xff);
206 	device->buffer[device->pos++] = (unsigned char)((c >> 16) & 0xff);
207 	device->buffer[device->pos++] = (unsigned char)((c >> 8) & 0xff);
208 	device->buffer[device->pos++] = (unsigned char)(c & 0xff);
209 
210 	return c;
211 }
212 
213 int
mbfl_memory_device_strcat(mbfl_memory_device * device,const char * psrc)214 mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
215 {
216 	int len;
217 	unsigned char *w;
218 	const unsigned char *p;
219 
220 	len = 0;
221 	p = psrc;
222 	while (*p) {
223 		p++;
224 		len++;
225 	}
226 
227 	if ((device->pos + len) >= device->length) {
228 		/* reallocate buffer */
229 		int newlen = device->length + (len + MBFL_MEMORY_DEVICE_ALLOC_SIZE)*sizeof(unsigned char);
230 		unsigned char *tmp = (unsigned char *)mbfl_realloc((void *)device->buffer, newlen*sizeof(unsigned char));
231 		if (tmp == NULL) {
232 			return -1;
233 		}
234 		device->length = newlen;
235 		device->buffer = tmp;
236 	}
237 
238 	p = psrc;
239 	w = &device->buffer[device->pos];
240 	device->pos += len;
241 	while (len > 0) {
242 		*w++ = *p++;
243 		len--;
244 	}
245 
246 	return len;
247 }
248 
249 int
mbfl_memory_device_strncat(mbfl_memory_device * device,const char * psrc,int len)250 mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len)
251 {
252 	unsigned char *w;
253 
254 	if ((device->pos + len) >= device->length) {
255 		/* reallocate buffer */
256 		int newlen = device->length + len + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
257 		unsigned char *tmp = (unsigned char *)mbfl_realloc((void *)device->buffer, newlen*sizeof(unsigned char));
258 		if (tmp == NULL) {
259 			return -1;
260 		}
261 		device->length = newlen;
262 		device->buffer = tmp;
263 	}
264 
265 	w = &device->buffer[device->pos];
266 	device->pos += len;
267 	while (len > 0) {
268 		*w++ = *psrc++;
269 		len--;
270 	}
271 
272 	return len;
273 }
274 
275 int
mbfl_memory_device_devcat(mbfl_memory_device * dest,mbfl_memory_device * src)276 mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src)
277 {
278 	int n;
279 	unsigned char *p, *w;
280 
281 	if ((dest->pos + src->pos) >= dest->length) {
282 		/* reallocate buffer */
283 		int newlen = dest->length + src->pos + MBFL_MEMORY_DEVICE_ALLOC_SIZE;
284 		unsigned char *tmp = (unsigned char *)mbfl_realloc((void *)dest->buffer, newlen*sizeof(unsigned char));
285 		if (tmp == NULL) {
286 			return -1;
287 		}
288 		dest->length = newlen;
289 		dest->buffer = tmp;
290 	}
291 
292 	p = src->buffer;
293 	w = &dest->buffer[dest->pos];
294 	n = src->pos;
295 	dest->pos += n;
296 	while (n > 0) {
297 		*w++ = *p++;
298 		n--;
299 	}
300 
301 	return n;
302 }
303 
304 void
mbfl_wchar_device_init(mbfl_wchar_device * device)305 mbfl_wchar_device_init(mbfl_wchar_device *device)
306 {
307 	if (device) {
308 		device->buffer = (unsigned int *)0;
309 		device->length = 0;
310 		device->pos= 0;
311 		device->allocsz = MBFL_MEMORY_DEVICE_ALLOC_SIZE;
312 	}
313 }
314 
315 void
mbfl_wchar_device_clear(mbfl_wchar_device * device)316 mbfl_wchar_device_clear(mbfl_wchar_device *device)
317 {
318 	if (device) {
319 		if (device->buffer) {
320 			mbfl_free(device->buffer);
321 		}
322 		device->buffer = (unsigned int*)0;
323 		device->length = 0;
324 		device->pos = 0;
325 	}
326 }
327 
328 int
mbfl_wchar_device_output(int c,void * data)329 mbfl_wchar_device_output(int c, void *data)
330 {
331 	mbfl_wchar_device *device = (mbfl_wchar_device *)data;
332 
333 	if (device->pos >= device->length) {
334 		/* reallocate buffer */
335 		int newlen;
336 		unsigned int *tmp;
337 
338 		newlen = device->length + device->allocsz;
339 		tmp = (unsigned int *)mbfl_realloc((void *)device->buffer, newlen*sizeof(int));
340 		if (tmp == NULL) {
341 			return -1;
342 		}
343 		device->length = newlen;
344 		device->buffer = tmp;
345 	}
346 
347 	device->buffer[device->pos++] = c;
348 
349 	return c;
350 }
351