gbx_value.c

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

  *((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 �re coh�ent 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;
    value->_array.keep = TRUE; // We suppose that the array goes to the stack
  }
  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;
  }
}