Return to mbfl_memory_device.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / libmbfl / mbfl |
1.1 misho 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 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 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 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 102: mbfl_memory_device_reset(mbfl_memory_device *device) 103: { 104: if (device) { 105: device->pos = 0; 106: } 107: } 108: 109: void 110: mbfl_memory_device_unput(mbfl_memory_device *device) 111: { 112: if (device->pos > 0) { 113: device->pos--; 114: } 115: } 116: 117: mbfl_string * 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 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 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 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 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 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 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 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 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 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: }