Annotation of embedaddon/php/ext/mbstring/libmbfl/mbfl/mbfl_memory_device.c, revision 1.1
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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mbfl_memory_device.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / libmbfl / mbfl