libRASCH

Home   General About libRASCH/News Design Screen shots Sample programs (with source code) License   Download libRASCH Tools   Documentation User Developer   Resources Mailing list Supported Formats Plugins Status Links   Contact About this site   Last updated Tue Mar 27 23:03:54 2007

value.c Go to the documentation of this file. /*-------------------------------------------------------------------------- * * Copyright (C) 2004, Raphael Schneider * See the file COPYING for information on usage and redistribution. * * $Header: /home/cvs_repos/librasch/src/value.c,v 1.6 2004/06/30 09:52:50 rasch Exp $ * *--------------------------------------------------------------------------*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <assert.h> #include <locale.h> #ifdef WIN32 #include <windows.h> #endif #define _LIBRASCH_BUILD #include <ra.h> #include <ra_priv.h> #include <pl_general.h> LIBRAAPI value_handle ra_value_malloc() { struct ra_value *v; v = malloc(sizeof(struct ra_value)); memset(v, 0, sizeof(struct ra_value)); v->handle_id = RA_HANDLE_VALUE; return (value_handle)v; } /* ra_value_malloc() */ LIBRAAPI void ra_value_free(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); free(v); } /* ra_value_free() */ int valid_value_handle(value_handle vh, int line_num) { int ok = 1; struct ra_value *v = (struct ra_value *)vh; if (!v) return ok; if (v->handle_id != RA_HANDLE_VALUE) ok = 0; if (!ok) /* TODO: add condition to print only when LIBRASCH_DEBUG is set */ { fprintf(stderr, "called from line %d\n", line_num); assert(0); } return ok; } /* valid_value_handle() */ LIBRAAPI void ra_value_reset(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); } /* ra_value_reset() */ LIBRAAPI long ra_value_get_type(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return RA_VALUE_TYPE_NONE; return v->utype; } /* ra_value_get_type() */ LIBRAAPI int ra_value_is_ok(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return 0; return v->value_is_valid; } /* ra_value_is_ok() */ LIBRAAPI long ra_value_get_num_elem(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return 0; return v->num_values; } /* ra_value_get_num_elem() */ LIBRAAPI long ra_value_get_info(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return RA_INFO_NONE; return v->id; } /* ra_value_get_info() */ LIBRAAPI const char * ra_value_get_name(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return NULL; utf8_to_local(v->name, v->name_locale, RA_VALUE_NAME_MAX); return v->name_locale; } /* ra_value_get_name() */ LIBRAAPI const char * ra_value_get_desc(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return NULL; utf8_to_local(v->desc, v->desc_locale, RA_VALUE_DESC_MAX); return v->desc_locale; } /* ra_value_get_desc() */ LIBRAAPI int ra_value_set_number(value_handle vh, long number) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return -1; v->number = number; return 0; } /* ra_value_set_number() */ LIBRAAPI long ra_value_get_number(value_handle vh) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return 0; return v->number; } /* ra_value_get_number() */ int set_meta_info(value_handle vh, const char *name, const char *desc, int id) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return -1; if (name && (name[0] != '\0')) { strncpy(v->name, gettext(name), RA_VALUE_NAME_MAX-1); v->name[RA_VALUE_NAME_MAX-1] = '\0'; } else v->name[0] = '\0'; if (desc && (desc[0] != '\0')) { strncpy(v->desc, gettext(desc), RA_VALUE_DESC_MAX-1); v->desc[RA_VALUE_DESC_MAX-1] = '\0'; } else v->desc[0] = '\0'; v->id = id; return 0; } /* set_meta_info() */ LIBRAAPI void ra_value_set_short(value_handle vh, const short value) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value.s = value; v->utype = RA_VALUE_TYPE_SHORT; v->value_is_valid = 1; } /* ra_value_set_short() */ LIBRAAPI void ra_value_set_long(value_handle vh, const long value) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value.l = value; v->utype = RA_VALUE_TYPE_LONG; v->value_is_valid = 1; } /* ra_value_set_long() */ LIBRAAPI void ra_value_set_double(value_handle vh, const double value) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value.d = value; v->utype = RA_VALUE_TYPE_DOUBLE; v->value_is_valid = 1; } /* ra_value_set_double() */ LIBRAAPI void ra_value_set_string(value_handle vh, const char *string) { struct ra_value *v = (struct ra_value *)vh; char *conv = NULL; size_t len; if (!string || !v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value_locale.c = ra_alloc_mem(strlen(string) + 1); memset(v->value_locale.c, '\0', strlen(string)+1); if (v->value_locale.c != NULL) strncpy(v->value_locale.c, string, strlen(string)); /* now convert it to UTF-8 and store it */ if (strlen(string) > 0) { len = strlen(string) * 2; conv = calloc(len, 1); local_to_utf8(string, conv, len); len = strlen(conv); v->value.c = ra_alloc_mem(len + 1); memset(v->value.c, '\0', len+1); if (v->value.c != NULL) strncpy(v->value.c, conv, len); free(conv); } else { v->value.c = ra_alloc_mem(1); v->value.c[0] = '\0'; } v->utype = RA_VALUE_TYPE_CHAR; v->value_is_valid = 1; } /* ra_value_set_string() */ LIBRAAPI void ra_value_set_string_utf8(value_handle vh, const char *string) { struct ra_value *v = (struct ra_value *)vh; char *conv = NULL; size_t len; if (!string || !v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value.c = ra_alloc_mem(strlen(string) + 1); memset(v->value.c, '\0', strlen(string)+1); if (v->value.c != NULL) strcpy(v->value.c, string); /* now convert it to locale setting and store it */ if (strlen(string) > 0) { len = strlen(string) * 2; conv = calloc(len, 1); utf8_to_local(string, conv, len); len = strlen(conv); v->value_locale.c = ra_alloc_mem(len + 1); memset(v->value_locale.c, '\0', len+1); if (v->value_locale.c != NULL) strcpy(v->value_locale.c, conv); free(conv); } else { v->value_locale.c = ra_alloc_mem(1); v->value_locale.c[0] = '\0'; } v->utype = RA_VALUE_TYPE_CHAR; v->value_is_valid = 1; } /* ra_value_set_string_utf8() */ LIBRAAPI void ra_value_set_voidp(value_handle vh, const void *value) { struct ra_value *v = (struct ra_value *)vh; if (!v || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value.vp = (void *)value; v->utype = RA_VALUE_TYPE_VOIDP; v->value_is_valid = 1; } /* ra_value_set_voidp() */ LIBRAAPI void ra_value_set_short_array(value_handle vh, const short *array, long num) { struct ra_value *v = (struct ra_value *)vh; long size; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); size = sizeof(short) * num; v->value.sp = ra_alloc_mem(size); if (v->value.sp) { memcpy(v->value.sp, array, size); v->utype = RA_VALUE_TYPE_SHORT_ARRAY; v->num_values = num; } v->value_is_valid = 1; } /* ra_value_set_short_array() */ LIBRAAPI void ra_value_set_long_array(value_handle vh, const long *array, long num) { struct ra_value *v = (struct ra_value *)vh; long size; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); size = sizeof(long) * num; v->value.lp = ra_alloc_mem(size); if (v->value.lp) { memcpy(v->value.lp, array, size); v->utype = RA_VALUE_TYPE_LONG_ARRAY; v->num_values = num; } v->value_is_valid = 1; } /* ra_value_set_long_array() */ LIBRAAPI void ra_value_set_double_array(value_handle vh, const double *array, long num) { struct ra_value *v = (struct ra_value *)vh; long size; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); size = sizeof(double) * num; v->value.dp = ra_alloc_mem(size); if (v->value.dp) { memcpy(v->value.dp, array, size); v->utype = RA_VALUE_TYPE_DOUBLE_ARRAY; v->num_values = num; } v->value_is_valid = 1; } /* ra_value_set_double_array() */ LIBRAAPI void ra_value_set_string_array(value_handle vh, const char **array, long num) { struct ra_value *v = (struct ra_value *)vh; long size; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); size = sizeof(char *) * num; v->value_locale.cp = ra_alloc_mem(size); if (v->value_locale.cp) { long l; for (l = 0; l < num; l++) { v->value_locale.cp[l] = ra_alloc_mem(strlen(array[l]) + 1); memset(v->value_locale.cp[l], '\0', strlen(array[l])+1); if (v->value_locale.cp[l]) memcpy(v->value_locale.cp[l], array[l], strlen(array[l]) + 1); } } /* convert all strings to UTF-8 encoding and store them */ v->value.cp = ra_alloc_mem(size); if (v->value.cp) { long l; size_t len; char *conv = NULL; for (l = 0; l < num; l++) { if (strlen(array[l]) > 0) { len = strlen(array[l]) * 2; conv = calloc(len, 1); local_to_utf8(array[l], conv, len); len = strlen(conv); v->value.cp[l] = ra_alloc_mem(len + 1); memset(v->value.cp[l], '\0', len+1); if (v->value.cp[l]) memcpy(v->value.cp[l], conv, len + 1); free(conv); } else { v->value.cp[l] = ra_alloc_mem(1); v->value.cp[l][0] = '\0'; } } } v->utype = RA_VALUE_TYPE_CHAR_ARRAY; v->num_values = num; v->value_is_valid = 1; } /* ra_value_set_string_array() */ LIBRAAPI void ra_value_set_string_array_utf8(value_handle vh, const char **array, long num) { struct ra_value *v = (struct ra_value *)vh; long size; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); size = sizeof(char *) * num; v->value.cp = ra_alloc_mem(size); if (v->value.cp) { long l; for (l = 0; l < num; l++) { v->value.cp[l] = ra_alloc_mem(strlen(array[l]) + 1); memset(v->value.cp[l], '\0', strlen(array[l])+1); if (v->value.cp[l]) memcpy(v->value.cp[l], array[l], strlen(array[l]) + 1); } } /* convert all strings to current used encoding scheme and store them */ v->value_locale.cp = ra_alloc_mem(size); if (v->value_locale.cp) { long l; size_t len; char *conv = NULL; for (l = 0; l < num; l++) { if (strlen(array[l]) > 0) { len = strlen(array[l]) * 2; conv = calloc(len, 1); utf8_to_local(array[l], conv, len); len = strlen(conv); v->value_locale.cp[l] = ra_alloc_mem(len + 1); memset(v->value_locale.cp[l], '\0', len+1); if (v->value_locale.cp[l]) memcpy(v->value_locale.cp[l], conv, len + 1); free(conv); } else { v->value_locale.cp[l] = ra_alloc_mem(1); v->value_locale.cp[l][0] = '\0'; } } } v->utype = RA_VALUE_TYPE_CHAR_ARRAY; v->num_values = num; v->value_is_valid = 1; } /* ra_value_set_string_array_utf8() */ LIBRAAPI void ra_value_set_voidp_array(value_handle vh, const void **array, long num) { struct ra_value *v = (struct ra_value *)vh; long size; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); size = sizeof(void *) * num; v->value.vpp = ra_alloc_mem(size); if (v->value.vpp) { memcpy(v->value.vpp, array, size); v->utype = RA_VALUE_TYPE_VOIDP_ARRAY; v->num_values = num; } v->value_is_valid = 1; } /* ra_value_set_voidp_array() */ LIBRAAPI void ra_value_set_vh_array(value_handle vh, const value_handle *array, long num) { struct ra_value *v = (struct ra_value *)vh; long l; if (!v || !array || !valid_value_handle(vh, __LINE__)) return; free_mem(v); v->value.vhp = ra_alloc_mem(sizeof(value_handle) * num); if (v->value.vhp) { for (l = 0; l < num; l++) { v->value.vhp[l] = ra_value_malloc(); ra_value_copy(v->value.vhp[l], array[l]); } v->utype = RA_VALUE_TYPE_VH_ARRAY; v->num_values = num; } v->value_is_valid = 1; } /* ra_value_set_vh_array() */ LIBRAAPI short ra_value_get_short(value_handle vh) { short ret = 0; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_SHORT: ret = v->value.s; break; case RA_VALUE_TYPE_LONG: ret = (short)(v->value.l); break; case RA_VALUE_TYPE_DOUBLE: ret = (short)(v->value.d); break; } return ret; } /* ra_value_get_short() */ LIBRAAPI long ra_value_get_long(value_handle vh) { long ret = 0; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_SHORT: ret = (long)(v->value.s); break; case RA_VALUE_TYPE_LONG: ret = v->value.l; break; case RA_VALUE_TYPE_DOUBLE: ret = (long)(v->value.d); break; } return ret; } /* ra_value_get_long() */ LIBRAAPI double ra_value_get_double(value_handle vh) { double ret = 0.0; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_SHORT: ret = (double)(v->value.s); break; case RA_VALUE_TYPE_LONG: ret = (double)(v->value.l); break; case RA_VALUE_TYPE_DOUBLE: ret = v->value.d; break; } return ret; } /* ra_value_get_double() */ LIBRAAPI const char * ra_value_get_string(value_handle vh) { const char *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_CHAR: ret = v->value_locale.c; break; } return ret; } /* ra_value_get_string() */ LIBRAAPI const char * ra_value_get_string_utf8(value_handle vh) { const char *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_CHAR: ret = v->value.c; break; } return ret; } /* ra_value_get_string_utf8() */ LIBRAAPI const void * ra_value_get_voidp(value_handle vh) { void *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_VOIDP: ret = v->value.vp; break; } return ret; } /* ra_value_get_voidp() */ LIBRAAPI const short * ra_value_get_short_array(value_handle vh) { const short *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_SHORT_ARRAY: ret = v->value.sp; break; } return ret; } /* ra_value_get_short_array() */ LIBRAAPI const long * ra_value_get_long_array(value_handle vh) { const long *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_LONG_ARRAY: ret = v->value.lp; break; } return ret; } /* ra_value_get_long_array() */ LIBRAAPI const double * ra_value_get_double_array(value_handle vh) { const double *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_DOUBLE_ARRAY: ret = v->value.dp; break; } return ret; } /* ra_value_get_double_array() */ LIBRAAPI const char ** ra_value_get_string_array(value_handle vh) { const char **ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_CHAR_ARRAY: ret = (const char **)(v->value_locale.cp); break; } return ret; } /* ra_value_get_string_array() */ LIBRAAPI const char ** ra_value_get_string_array_utf8(value_handle vh) { const char **ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_CHAR_ARRAY: ret = (const char **)(v->value.cp); break; } return ret; } /* ra_value_get_string_array_utf8() */ LIBRAAPI const void ** ra_value_get_voidp_array(value_handle vh) { const void **ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_VOIDP_ARRAY: ret = (const void **)(v->value.vpp); break; } return ret; } /* ra_value_get_voidp_array() */ LIBRAAPI const value_handle * ra_value_get_vh_array(value_handle vh) { const value_handle *ret = NULL; struct ra_value *v = (struct ra_value *)vh; if (!v || !(v->value_is_valid) || !valid_value_handle(vh, __LINE__)) return ret; switch (v->utype) { case RA_VALUE_TYPE_VH_ARRAY: ret = v->value.vhp; break; } return ret; } /* ra_value_get_vh_array() */ LIBRAAPI int ra_value_copy(value_handle dest, value_handle src) { struct ra_value *d = (struct ra_value *)dest; struct ra_value *s = (struct ra_value *)src; int ret = 0; if (!d || !s || !valid_value_handle(d, __LINE__) || !valid_value_handle(s, __LINE__)) return -1; free_mem(d); strncpy(d->name, s->name, RA_VALUE_NAME_MAX); strncpy(d->desc, s->desc, RA_VALUE_DESC_MAX); d->id = s->id; d->can_be_changed = 1; if (!s->value_is_valid) return -1; switch (s->utype) { case RA_VALUE_TYPE_SHORT: ra_value_set_short(dest, s->value.s); break; case RA_VALUE_TYPE_LONG: ra_value_set_long(dest, s->value.l); break; case RA_VALUE_TYPE_DOUBLE: ra_value_set_double(dest, s->value.d); break; case RA_VALUE_TYPE_CHAR: ra_value_set_string(dest, s->value.c); break; case RA_VALUE_TYPE_VOIDP: ra_value_set_voidp(dest, s->value.vp); break; case RA_VALUE_TYPE_SHORT_ARRAY: ra_value_set_short_array(dest, s->value.sp, s->num_values); break; case RA_VALUE_TYPE_LONG_ARRAY: ra_value_set_long_array(dest, s->value.lp, s->num_values); break; case RA_VALUE_TYPE_DOUBLE_ARRAY: ra_value_set_double_array(dest, s->value.dp, s->num_values); break; case RA_VALUE_TYPE_CHAR_ARRAY: ra_value_set_string_array(dest, (const char **)(s->value.cp), s->num_values); break; case RA_VALUE_TYPE_VOIDP_ARRAY: ra_value_set_voidp_array(dest, (const void **)(s->value.vpp), s->num_values); break; case RA_VALUE_TYPE_VH_ARRAY: ra_value_set_vh_array(dest, s->value.vhp, s->num_values); break; default: ret = -1; break; } return ret; } /* ra_value_copy() */ LIBRAAPI int ra_value_get_single_elem(value_handle dest, value_handle src, long elem_num) { struct ra_value *d = (struct ra_value *)dest; struct ra_value *s = (struct ra_value *)src; int ret = 0; if (!d || !s || !valid_value_handle(d, __LINE__) || !valid_value_handle(s, __LINE__) || (elem_num < 0)) return -1; if (elem_num >= s->num_values) return -1; if (!s->value_is_valid) return -1; free_mem(d); strncpy(d->name, s->name, RA_VALUE_NAME_MAX); strncpy(d->desc, s->desc, RA_VALUE_DESC_MAX); d->id = s->id; d->can_be_changed = 1; switch (s->utype) { case RA_VALUE_TYPE_SHORT: ra_value_set_short(dest, s->value.s); break; case RA_VALUE_TYPE_LONG: ra_value_set_long(dest, s->value.l); break; case RA_VALUE_TYPE_DOUBLE: ra_value_set_double(dest, s->value.d); break; case RA_VALUE_TYPE_CHAR: ra_value_set_string(dest, s->value.c); break; case RA_VALUE_TYPE_VOIDP: ra_value_set_voidp(dest, s->value.vp); break; case RA_VALUE_TYPE_SHORT_ARRAY: ra_value_set_short(dest, s->value.sp[elem_num]); break; case RA_VALUE_TYPE_LONG_ARRAY: ra_value_set_long(dest, s->value.lp[elem_num]); break; case RA_VALUE_TYPE_DOUBLE_ARRAY: ra_value_set_double(dest, s->value.dp[elem_num]); break; case RA_VALUE_TYPE_CHAR_ARRAY: ra_value_set_string(dest, s->value.cp[elem_num]); break; case RA_VALUE_TYPE_VOIDP_ARRAY: ra_value_set_voidp(dest, s->value.vpp[elem_num]); break; case RA_VALUE_TYPE_VH_ARRAY: ret = ra_value_copy(dest, s->value.vhp[elem_num]); break; default: ret = -1; break; } return ret; } /* ra_value_get_single_elem() */ void free_mem(struct ra_value *v) { v->value_is_valid = 0; v->num_values = 0; switch (v->utype) { case RA_VALUE_TYPE_CHAR: if (v->value.c) ra_free_mem(v->value.c); v->value.c = NULL; if (v->value_locale.c) ra_free_mem(v->value_locale.c); v->value_locale.c = NULL; break; case RA_VALUE_TYPE_SHORT_ARRAY: if (v->value.sp) ra_free_mem(v->value.sp); v->value.sp = NULL; break; case RA_VALUE_TYPE_LONG_ARRAY: if (v->value.lp) ra_free_mem(v->value.lp); v->value.lp = NULL; break; case RA_VALUE_TYPE_DOUBLE_ARRAY: if (v->value.dp) ra_free_mem(v->value.dp); v->value.dp = NULL; break; case RA_VALUE_TYPE_CHAR_ARRAY: if (v->value.cp) { long l; for (l = 0; l < v->num_values; l++) { if (v->value.cp[l]) ra_free_mem(v->value.cp[l]); } ra_free_mem(v->value.cp); } v->value.cp = NULL; if (v->value_locale.cp) { long l; for (l = 0; l < v->num_values; l++) { if (v->value_locale.cp[l]) ra_free_mem(v->value_locale.cp[l]); } ra_free_mem(v->value_locale.cp); } v->value_locale.cp = NULL; break; case RA_VALUE_TYPE_VOIDP_ARRAY: if (v->value.vpp) ra_free_mem(v->value.vpp); v->value.vpp = NULL; break; case RA_VALUE_TYPE_VH_ARRAY: if (v->value.vhp) { long l; for (l = 0; l < v->num_values; l++) ra_value_free(v->value.vhp[l]); ra_free_mem(v->value.vhp); } v->value.vhp = NULL; break; } v->utype = RA_VALUE_TYPE_NONE; } /* free_mem() */