gbx_value.c
/***************************************************************************
value.c
Datatype management routines. Conversions between each Gambas datatype,
and conversions between Gambas datatypes and native datatypes.
(c) 2000-2004 Benoît Minisini <gambas@users.sourceforge.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***************************************************************************/
#include "gb_common.h"
#include "gb_common_case.h"
#include <float.h>
#include <math.h>
#include "gbx_math.h"
#include "gbx_type.h"
#include "gbx_array.h"
#include "gbx_string.h"
#include "gbx_number.h"
#include "gbx_object.h"
#include "gbx_variant.h"
#include "gbx_date.h"
#include "gbx_exec.h"
#include "gbx_local.h"
#include "gb_common_buffer.h"
#include "gbx_value.h"
PUBLIC void VALUE_default(VALUE *value, TYPE type)
{
static void *jump[16] = {
&&__VOID, &&__BOOLEAN, &&__BYTE, &&__SHORT, &&__INTEGER, &&__LONG, &&__FLOAT, &&__DATE,
&&__STRING, &&__STRING, &&__VARIANT, &&__ARRAY, &&__STRUCT, &&__FUNCTION, &&__CLASS, &&__NULL
};
value->type = type;
if (TYPE_is_object(type))
goto __OBJECT;
else
goto *jump[type];
__BOOLEAN:
__BYTE:
__SHORT:
__INTEGER:
value->_integer.value = 0;
return;
__FLOAT:
value->_float.value = 0;
return;
__STRING:
value->_string.addr = NULL;
value->_string.start = 0;
value->_string.len = 0;
return;
__VARIANT:
value->_variant.vtype = T_NULL;
return;
__DATE:
value->_date.date = 0;
value->_date.time = 0;
return;
__VOID:
return;
__OBJECT:
value->_object.class = (CLASS *)type;
value->_object.object = NULL;
return;
__LONG:
__ARRAY:
__STRUCT:
__FUNCTION:
__CLASS:
__NULL:
ERROR_panic("VALUE_default: Unknown default type");
}
PUBLIC void VALUE_convert(VALUE *value, TYPE type)
{
static void *jump[16][16] =
{
/* void b c h i l f d cs s v array struct func class n */
/* void */ { &&__OK, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, &&__NR, },
/* b */ { &&__N, &&__OK, &&__b2c, &&__b2h, &&__TYPE, &&__N, &&__b2f, &&__N, &&__b2s, &&__b2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* c */ { &&__N, &&__c2b, &&__OK, &&__c2h, &&__TYPE, &&__N, &&__c2f, &&__c2d, &&__c2s, &&__c2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* h */ { &&__N, &&__h2b, &&__h2c, &&__OK, &&__TYPE, &&__N, &&__h2f, &&__h2d, &&__h2s, &&__h2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* i */ { &&__N, &&__i2b, &&__i2c, &&__i2h, &&__OK, &&__N, &&__i2f, &&__i2d, &&__i2s, &&__i2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* l */ { &&__N, &&__N, &&__N, &&__N, &&__N, &&__OK, &&__N, &&__N, &&__N, &&__N, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* f */ { &&__N, &&__f2b, &&__f2c, &&__f2h, &&__f2i, &&__N, &&__OK, &&__f2d, &&__f2s, &&__f2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* d */ { &&__N, &&__N, &&__d2c, &&__d2h, &&__d2i, &&__N, &&__d2f, &&__OK, &&__d2s, &&__d2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* cs */ { &&__N, &&__s2b, &&__s2c, &&__s2h, &&__s2i, &&__N, &&__s2f, &&__s2d, &&__OK, &&__OK, &&__s2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* s */ { &&__N, &&__s2b, &&__s2c, &&__s2h, &&__s2i, &&__N, &&__s2f, &&__s2d, &&__OK, &&__OK, &&__s2v, &&__N, &&__N, &&__N, &&__N, &&__N, },
/* v */ { &&__N, &&__v2, &&__v2, &&__v2, &&__v2, &&__N, &&__v2, &&__v2, &&__v2, &&__v2, &&__OK, &&__N, &&__N, &&__N, &&__N, &&__v2, },
/* array */ { &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__OK, &&__N, &&__N, &&__N, &&__N, },
/* struct */ { &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__OK, &&__N, &&__N, &&__N, },
/* func */ { &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__OK, &&__N, &&__N, },
/* class */ { &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__OK, &&__N, },
/* null */ { &&__N, &&__n2b, &&__N, &&__N, &&__N, &&__N, &&__N, &&__N, &&__n2s, &&__n2s, &&__2v, &&__N, &&__N, &&__N, &&__N, &&__OK, },
};
long len;
char *addr;
long index;
CLASS *class;
boolean test;
__CONV:
if ((type | value->type) >> 4)
goto __OBJECT;
else
goto *jump[value->type][type];
__c2b:
__h2b:
__i2b:
value->_integer.value = (value->_integer.value != 0) ? -1 : 0;
goto __TYPE;
__f2b:
value->_integer.value = (value->_float.value != 0) ? -1 : 0;
goto __TYPE;
__b2c:
__h2c:
__i2c:
value->_integer.value = (unsigned char)value->_integer.value;
goto __TYPE;
__f2c:
value->_integer.value = (unsigned char)value->_float.value;
goto __TYPE;
__b2h:
__c2h:
__i2h:
value->_integer.value = (short)value->_integer.value;
goto __TYPE;
__f2h:
value->_integer.value = (short)value->_float.value;
goto __TYPE;
__f2i:
value->_integer.value = (long)value->_float.value;
goto __TYPE;
__b2f:
__c2f:
__h2f:
__i2f:
value->_float.value = value->_integer.value;
goto __TYPE;
__c2d:
__h2d:
__i2d:
value->_date.date = Max(0, value->_integer.value);
value->_date.time = 0;
goto __TYPE;
__f2d:
index = (long)fix(value->_float.value);
value->_date.time = (long)((value->_float.value - index) * 86400000.0 + 0.5);
value->_date.date = index;
goto __TYPE;
__d2c:
__d2h:
__d2i:
value->_integer.value = value->_date.date;
value->type = T_INTEGER;
goto *jump[T_INTEGER][type];
__d2f:
value->_float.value = (double)value->_date.date + (double)value->_date.time / 86400000.0;
goto __TYPE;
__b2s:
if (value->_boolean.value)
STRING_char_value(value, 'T');
else
STRING_void_value(value);
return;
__c2s:
__h2s:
__i2s:
len = sprintf(COMMON_buffer, "%ld", value->_integer.value);
STRING_new_temp_value(value, COMMON_buffer, len);
BORROW(value);
return;
__f2s:
LOCAL_format_number(value->_float.value, LF_GENERAL_NUMBER, NULL, 0, &addr, &len, FALSE);
STRING_new_temp_value(value, addr, len);
BORROW(value);
return;
__d2s:
len = DATE_to_string(COMMON_buffer, value);
STRING_new_temp_value(value, COMMON_buffer, len);
BORROW(value);
return;
__s2b:
addr = value->_string.addr;
value->_integer.value = ((addr != NULL) && (value->_string.len != 0)) ? -1 : 0;
if (value->type == T_STRING)
STRING_unref(&addr);
goto __TYPE;
__s2c:
__s2h:
__s2i:
addr = value->type == T_STRING ? value->_string.addr : NULL;
if (NUMBER_from_string(NB_READ_INTEGER, value->_string.addr + value->_string.start, value->_string.len, value))
goto __N;
STRING_unref(&addr);
goto *jump[T_INTEGER][type];
__s2f:
addr = value->type == T_STRING ? value->_string.addr : NULL;
if (NUMBER_from_string(NB_READ_FLOAT, value->_string.addr + value->_string.start, value->_string.len, value))
goto __N;
STRING_unref(&addr);
return;
__s2d:
addr = value->type == T_STRING ? value->_string.addr : NULL;
if (DATE_from_string(value->_string.addr + value->_string.start, value->_string.len, value, FALSE))
goto __N;
STRING_unref(&addr);
return;
__n2b:
value->_integer.value = 0;
goto __TYPE;
__n2s:
STRING_void_value(value);
return;
__v2:
/* ATTENTION !
VALUE_read sert normalement à lire un stockage en mémoire.
On le détourne ici pour convertir le variant.
Mais si le variant contient un T_STRING, ça doit rester un T_STRING ! */
index = value->_variant.vtype;
if (index != T_NULL)
VALUE_read(value, &value->_variant.value, value->_variant.vtype);
value->type = index;
goto __CONV;
__s2v:
STRING_copy_from_value_temp(&addr, value);
if (addr != value->_string.addr)
{
STRING_ref(addr);
if (value->type == T_STRING)
STRING_unref(&value->_string.addr);
}
*((char **)value->_variant.value) = addr;
value->_variant.vtype = T_STRING;
goto __TYPE;
__2v:
/* VALUE_put ne fonctionne pas avec T_STRING ! */
if (value->type != T_NULL)
VALUE_put(value, &value->_variant.value, value->type);
value->_variant.vtype = value->type;
goto __TYPE;
__OBJECT:
if (!TYPE_is_object(type))
{
if (type == T_BOOLEAN)
{
test = (value->_object.object != NULL);
OBJECT_UNREF(&value->_object.object, "VALUE_convert");
value->_boolean.value = test ? -1 : 0;
goto __TYPE;
}
if (type == T_VARIANT)
goto __2v;
goto __N;
}
if (!TYPE_is_object(value->type))
{
if (value->type == T_NULL)
{
OBJECT_null(value, (CLASS *)type); /* marche aussi pour type = T_OBJECT */
goto __TYPE;
}
if (value->type == T_VARIANT)
goto __v2;
if (value->type == T_CLASS)
{
class = value->_class.class;
CLASS_load(class);
if (class->auto_create)
value->_object.object = CLASS_auto_create(class, 0);
else
value->_object.object = class;
OBJECT_REF(value->_object.object, "VALUE_convert");
value->type = T_OBJECT;
/* on continue... */
}
else
goto __N;
}
if (value->type == T_OBJECT)
{
if (value->_object.object == NULL)
goto __TYPE;
class = OBJECT_class(value->_object.object);
/* on continue */
}
else
class = value->_object.class;
if (CLASS_is_virtual(class))
THROW(E_VIRTUAL);
if (type == T_OBJECT)
goto __TYPE;
__RETRY:
if ((class == (CLASS *)type) || CLASS_inherits(class, (CLASS *)type))
goto __TYPE;
if (value->type != T_OBJECT && value->_object.object)
{
class = OBJECT_class(value->_object.object);
value->type = T_OBJECT;
goto __RETRY;
}
THROW(E_TYPE, TYPE_get_name(type), TYPE_get_name((TYPE)class));
__TYPE:
value->type = type;
__OK:
return;
__N:
THROW(E_TYPE, TYPE_get_name(type), TYPE_get_name(value->type));
__NR:
THROW(E_NRETURN);
}
PUBLIC void VALUE_write(VALUE *value, void *addr, TYPE type)
{
static void *jump[16] = {
&&__VOID, &&__BOOLEAN, &&__BYTE, &&__SHORT, &&__INTEGER, &&__LONG, &&__FLOAT, &&__DATE,
&&__STRING, &&__STRING, &&__VARIANT, &&__ARRAY, &&__STRUCT, &&__FUNCTION, &&__CLASS, &&__NULL
};
char *str;
__CONV:
if (TYPE_is_object(type))
goto __OBJECT;
else
goto *jump[type];
__BOOLEAN:
VALUE_conv(value, type);
*((unsigned char *)addr) = (value->_boolean.value != 0 ? 1 : 0);
return;
__BYTE:
VALUE_conv(value, type);
*((unsigned char *)addr) = (unsigned char)(value->_byte.value);
return;
__SHORT:
VALUE_conv(value, type);
*((short *)addr) = (short)(value->_short.value);
return;
__INTEGER:
VALUE_conv(value, type);
*((long *)addr) = value->_integer.value;
return;
__FLOAT:
VALUE_conv(value, type);
*((double *)addr) = value->_float.value;
return;
__DATE:
VALUE_conv(value, type);
((long *)addr)[0] = value->_date.date;
((long *)addr)[1] = value->_date.time;
return;
__STRING:
/* Il faut faire l'affectation en deux temps au cas où
value->_string.addr == *addr ! */
VALUE_conv(value, type);
STRING_copy_from_value_temp(&str, value);
STRING_ref(str);
STRING_unref((char **)addr);
*((char **)addr) = str;
return;
__OBJECT:
VALUE_conv(value, type);
OBJECT_REF(value->_object.object, "VALUE_write");
OBJECT_UNREF(((void **)addr), "VALUE_write");
*((void **)addr) = value->_object.object;
return;
__VARIANT:
VARIANT_undo(value);
type = value->type;
if (type == T_CSTRING) type = T_STRING;
VARIANT_clear((VARIANT *)addr);
((VARIANT *)addr)->type = type;
/* Et si type ne fait pas partie des types valides pour cette fonction ?? */
if (type == T_NULL)
return;
addr = ((VARIANT *)addr)->value;
/*goto *jump[Min(T_OBJECT, type)];*/
goto __CONV;
/*
{
VARIANT *var = ((VARIANT *)addr);
VARIANT_free(var);
var->type = value->_variant.vtype;
VARIANT_copy(value->_variant.value, var->value);
if (TYPE_is_object(var->type))
OBJECT_$ref(*((void **)var->value));
return;
}
*/
__VOID:
__LONG:
__ARRAY:
__STRUCT:
__FUNCTION:
__CLASS:
__NULL:
ERROR_panic("Bad type (%d) for VALUE_write", type);
}
PUBLIC void VALUE_read(VALUE *value, void *addr, TYPE type)
{
static void *jump[16] = {
&&__VOID, &&__BOOLEAN, &&__BYTE, &&__SHORT, &&__INTEGER, &&__LONG, &&__FLOAT, &&__DATE,
&&__STRING, &&__CSTRING, &&__VARIANT, &&__ARRAY, &&__STRUCT, &&__FUNCTION, &&__CLASS, &&__NULL
};
char *str;
value->type = type;
if (TYPE_is_object(type))
goto __OBJECT;
else
goto *jump[type];
__BOOLEAN:
value->_boolean.value = (*((unsigned char *)addr) != 0) ? (-1) : 0;
return;
__BYTE:
value->_byte.value = *((unsigned char *)addr);
return;
__SHORT:
value->_short.value = *((short *)addr);
return;
__INTEGER:
value->_integer.value = *((long *)addr);
return;
__FLOAT:
value->_float.value = *((double *)addr);
return;
__DATE:
value->_date.date = ((long *)addr)[0];
value->_date.time = ((long *)addr)[1];
return;
__STRING:
str = *((char **)addr);
value->type = T_STRING;
value->_string.addr = str;
value->_string.start = 0;
/*value->_string.len = (str == NULL) ? 0 : strlen(str);*/
value->_string.len = STRING_length(str);
return;
__CSTRING:
str = *((char **)addr);
value->type = T_CSTRING;
value->_string.addr = str;
value->_string.start = 0;
value->_string.len = (str == NULL) ? 0 : strlen(str);
/*value->_string.len = STRING_length(str);*/
return;
__OBJECT:
value->_object.object = *((void **)addr);
return;
__VARIANT:
value->_variant.type = T_VARIANT;
value->_variant.vtype = ((VARIANT *)addr)->type;
/*if (value->_variant.vtype == T_STRING)
value->_variant.vtype = T_STRING;
else*/ if (value->_variant.vtype == T_VOID)
value->_variant.vtype = T_NULL;
VARIANT_copy(((VARIANT *)addr)->value, value->_variant.value);
return;
__VOID:
__LONG:
__ARRAY:
__STRUCT:
__CLASS:
__FUNCTION:
__NULL:
ERROR_panic("Bad type (%d) for VALUE_read", type);
}
/* Retourne TRUE s'il y a eu besoin d'allouer qqch */
/*
#define MAX_FREE_PTR 64
PRIVATE int free_count = 0;
PRIVATE void *free_ptr[MAX_FREE_PTR];
PRIVATE void add_free_ptr(void *ptr)
{
if (free_count >= MAX_FREE_PTR)
ERROR_panic("VALUE_put: too many pointers to free");
free_ptr[free_count] = ptr;
free_count++;
}
PUBLIC void VALUE_put_free(void)
{
int i;
for (i = 0; i < free_count; i++)
STRING_free((char **)&free_ptr[i]);
free_count = 0;
}
PUBLIC void VALUE_put_forget(void)
{
free_count = 0;
}
*/
PUBLIC void VALUE_put(VALUE *value, void *addr, TYPE type)
{
static void *jump[16] = {
&&__VOID, &&__BOOLEAN, &&__BYTE, &&__SHORT, &&__INTEGER, &&__LONG, &&__FLOAT, &&__DATE,
&&__STRING, &&__STRING, &&__VARIANT, &&__ARRAY, &&__STRUCT, &&__FUNCTION, &&__CLASS, &&__NULL
};
VALUE_conv(value, type);
if (TYPE_is_object(type))
goto __OBJECT;
else
goto *jump[type];
__BOOLEAN:
*((unsigned char *)addr) = (value->_boolean.value != 0 ? 1 : 0);
return;
__BYTE:
*((unsigned char *)addr) = (unsigned char)(value->_byte.value);
return;
__SHORT:
*((short *)addr) = (short)(value->_short.value);
return;
__INTEGER:
*((long *)addr) = value->_integer.value;
return;
__FLOAT:
*((double *)addr) = value->_float.value;
return;
__DATE:
/* Inverser au cas où value ~= addr */
((long *)addr)[1] = value->_date.time;
((long *)addr)[0] = value->_date.date;
return;
__STRING:
((long *)addr)[0] = (long)(value->_string.addr + value->_string.start);
((long *)addr)[1] = value->_string.len;
return;
__OBJECT:
*((void **)addr) = value->_object.object;
return;
__VARIANT:
*((VARIANT *)addr) = *((VARIANT *)&value->_variant.vtype);
return;
/*
if
type = value->type;
((VARIANT *)addr)->type = type;
addr = ((VARIANT *)addr)->value;
goto _conv;
*/
__VOID:
__LONG:
__ARRAY:
__STRUCT:
__CLASS:
__FUNCTION:
__NULL:
ERROR_panic("Bad type (%d) for VALUE_put", type);
}
PUBLIC void VALUE_free(void *addr, TYPE type)
{
if (type == T_STRING)
{
STRING_unref((char **)addr);
*((char **)addr) = NULL;
}
else if (TYPE_is_object(type))
{
OBJECT_unref((void **)addr);
*((void **)addr) = NULL;
}
else if (type == T_VARIANT)
{
VARIANT_free((VARIANT *)addr);
((VARIANT *)addr)->type = T_NULL;
}
}
PUBLIC void VALUE_to_string(VALUE *value, char **addr, long *len)
{
static void *jump[16] = {
&&__VOID, &&__BOOLEAN, &&__BYTE, &&__SHORT, &&__INTEGER, &&__LONG, &&__FLOAT, &&__DATE,
&&__STRING, &&__STRING, &&__VARIANT, &&__ARRAY, &&__STRUCT, &&__FUNCTION, &&__CLASS, &&__NULL
};
_conv:
if (TYPE_is_object(value->type))
goto __OBJECT;
else
goto *jump[value->type];
__NULL:
*addr = ""; /* Pour être cohérent avec print "" puisque Null == "" */
*len = 0;
return;
__BOOLEAN:
if (value->_boolean.value)
{
*addr = "True";
*len = 4;
}
else
{
*addr = "False";
*len = 5;
}
return;
__BYTE:
__SHORT:
__INTEGER:
*len = sprintf(COMMON_buffer, "%ld", value->_integer.value);
*addr = COMMON_buffer;
return;
__DATE:
LOCAL_format_date(DATE_split(value), LF_STANDARD, NULL, 0, addr, len);
return;
__FLOAT:
LOCAL_format_number(value->_float.value, LF_STANDARD, NULL, 0, addr, len, TRUE);
return;
__STRING:
*len = value->_string.len;
*addr = value->_string.addr + value->_string.start;
return;
__OBJECT:
if (VALUE_is_null(value))
goto __NULL;
*len = sprintf(COMMON_buffer, "(%s %p)", OBJECT_class(value->_object.object)->name, value->_object.object);
*addr = COMMON_buffer;
return;
__VARIANT:
VARIANT_undo(value);
goto _conv;
__VOID:
__LONG:
__ARRAY:
__STRUCT:
__FUNCTION:
__CLASS:
*len = sprintf(COMMON_buffer, "(%s ?)", TYPE_get_name(value->type));
*addr = COMMON_buffer;
/*THROW(E_TYPE, TYPE_get_name(T_STRING), TYPE_get_name(value->type));*/
}
PUBLIC void VALUE_from_string(VALUE *value, const char *addr, long len)
{
if (DATE_from_string(addr, len, value, TRUE)
&& NUMBER_from_string(NB_READ_BOTH | NB_READ_HEX_BIN | NB_LOCAL, addr, len, value))
{
if (len == 4 && strncasecmp(addr, "true", len) == 0)
{
value->type = T_BOOLEAN;
value->_boolean.value = -1;
}
else if (len == 5 && strncasecmp(addr, "false", len) == 0)
{
value->type = T_BOOLEAN;
value->_boolean.value = 0;
}
else
value->type = T_NULL;
}
}
PUBLIC void VALUE_class_read(CLASS *class, VALUE *value, char *addr, CTYPE ctype)
{
if (ctype.id == T_OBJECT)
{
VALUE_read(value, addr, (ctype.value >= 0) ? (TYPE)class->load->class_ref[ctype.value] : T_OBJECT);
}
else if (ctype.id == T_ARRAY)
{
value->type = T_ARRAY;
value->_array.desc = class->load->array[ctype.value];
value->_array.addr = addr;
}
else
VALUE_read(value, addr, (TYPE)ctype.id);
}
PUBLIC void VALUE_class_write(CLASS *class, VALUE *value, char *addr, CTYPE ctype)
{
if (ctype.id == T_OBJECT)
{
VALUE_write(value, addr, (ctype.value >= 0) ? (TYPE)class->load->class_ref[ctype.value] : T_OBJECT);
}
else if (ctype.id == T_ARRAY)
{
ERROR_panic("Don't know how to copy arrays");
}
else
VALUE_write(value, addr, (TYPE)ctype.id);
}
PUBLIC void VALUE_class_default(CLASS *class, VALUE *value, CTYPE ctype)
{
if (ctype.id == T_OBJECT)
{
VALUE_default(value, (ctype.value >= 0) ? (TYPE)class->load->class_ref[ctype.value] : T_OBJECT);
}
else if (ctype.id == T_ARRAY)
{
value->type = T_ARRAY;
value->_array.desc = class->load->array[ctype.value];
value->_array.keep = FALSE;
ARRAY_new(&value->_array.addr, (ARRAY_DESC *)value->_array.desc);
}
else
VALUE_default(value, (TYPE)ctype.id);
}
PUBLIC bool VALUE_is_null(VALUE *val)
{
if (val->type == T_NULL)
return TRUE;
if (VALUE_is_string(val) && (val->_string.addr == 0 || val->_string.len == 0))
return TRUE;
if (VALUE_is_object(val) && (val->_object.object == NULL))
return TRUE;
if (val->type == T_VARIANT)
{
if (val->_variant.vtype == T_NULL)
return TRUE;
if (val->_variant.vtype == T_STRING && *((char **)val->_variant.value) == NULL)
return TRUE;
if (TYPE_is_object(val->_variant.vtype) && *((void **)val->_variant.value) == NULL)
return TRUE;
}
return FALSE;
}
PUBLIC void VALUE_get_string(VALUE *val, char **text, long *length)
{
if (VALUE_is_null(val))
{
*text = 0;
*length = 0;
}
else
{
*length = val->_string.len;
if (*length)
*text = val->_string.start + val->_string.addr;
else
*text = NULL;
}
}
