// This file is part of SmallBASIC
//
// SmallBasic Variable Manager.
//
// This program is distributed under the terms of the GPL v2.0 or later
// Download the GNU Public License (GPL) from www.gnu.org
//
// Copyright(C) 2000 Nicholas Christopoulos

#include "common/sys.h"
#include "common/str.h"
#include "common/var.h"
#include "common/smbas.h"
#include "common/sberr.h"
#include "common/var_uds.h"
#include "common/var_hash.h"

#define ARR_ALLOC       256

/*
 * initialize a variable
 */
void v_init(var_t *v) {
  v->type = V_INT;
  v->const_flag = 0;
  v->v.i = 0;
}

/*
 * creates and returns a new variable
 */
var_t *v_new() {
  var_t *ptr;

  ptr = (var_t *) tmp_alloc(sizeof(var_t));
  v_init(ptr);
  return ptr;
}

/*
 * release variable
 */
void v_free(var_t *v) {
  int i;
  var_t *elem;

  switch (v->type) {
  case V_STR:
    if (v->v.p.ptr) {
      tmp_free(v->v.p.ptr);
    }
    v->v.p.ptr = NULL;
    v->v.p.size = 0;
    break;
  case V_ARRAY:
    if (v->v.a.size) {
      if (v->v.a.ptr) {
        for (i = 0; i < v->v.a.size; i++) {
          elem = (var_t *) (v->v.a.ptr + (sizeof(var_t) * i));
          v_free(elem);
        }

        tmp_free(v->v.a.ptr);
        v->v.a.ptr = NULL;
        v->v.a.size = 0;
      }
    }
    break;
  case V_UDS:
    uds_free(v);
    break;
  case V_HASH:
    hash_free_var(v);
    break;
  }

  v_init(v);
}

/*
 * returns true if the user's program must use this var as an empty var
 * this is usefull for arrays
 */
int v_isempty(var_t *var) {
  switch (var->type) {
  case V_STR:
    return (strlen((char *) var->v.p.ptr) == 0);
  case V_INT:
    return (var->v.i == 0);
  case V_UDS:
    return uds_is_empty(var);
  case V_HASH:
    return hash_is_empty(var);
  case V_PTR:
    return (var->v.ap.p == 0);
  case V_NUM:
    return (var->v.n == 0.0);
  case V_ARRAY:
    return (var->v.a.size == 0);
  }

  return 1;
}

/*
 * returns the length of the variable
 */
int v_length(var_t *var) {
  char tmpsb[64];

  switch (var->type) {
  case V_STR:
    return strlen((char *) var->v.p.ptr);
  case V_UDS:
    return uds_length(var);
  case V_HASH:
    return hash_length(var);
  case V_PTR:
    ltostr(var->v.ap.p, tmpsb);
    return strlen(tmpsb);
  case V_INT:
    ltostr(var->v.i, tmpsb);
    return strlen(tmpsb);
  case V_NUM:
    ftostr(var->v.n, tmpsb);
    return strlen(tmpsb);
  case V_ARRAY:
    return var->v.a.size;
  }

  return 1;
}

/*
 * returns the floating-point value of the variable v
 */
var_num_t v_getval(var_t *v) {
  if (v == NULL) {
    err_evsyntax();
  } else {
    switch (v->type) {
    case V_UDS:
      return uds_to_int(v);
    case V_HASH:
      return hash_to_int(v);
    case V_PTR:
      return v->v.ap.p;
    case V_INT:
      return v->v.i;
    case V_NUM:
      return v->v.n;
    case V_STR:
      return numexpr_sb_strtof((char *) v->v.p.ptr);
    default:
      err_varisarray();
    }
  }
  return 0;
}

/*
 * returns the integer value of the variable v
 */
var_int_t v_igetval(var_t *v) {
  if (v == 0) {
    err_evsyntax();
  } else {
    switch (v->type) {
    case V_UDS:
      return uds_to_int(v);
    case V_HASH:
      return hash_to_int(v);
    case V_PTR:
      return v->v.ap.p;
    case V_INT:
      return v->v.i;
    case V_NUM:
      return v->v.n;
    case V_STR:
      return numexpr_strtol((char *) v->v.p.ptr);
    default:
      err_varisarray();
    }
  }
  return 0;
}

/*
 * return array element pointer
 */
#if defined(OS_ADDR16)
var_t *v_getelemptr(var_t *v, word index)
#else
var_t *v_getelemptr(var_t *v, dword index)
#endif
{
  if (v->type == V_ARRAY) {
    if (index < v->v.a.size)
      return (var_t *) (v->v.a.ptr + (index * sizeof(var_t)));
    else {
      err_vararridx(index, v->v.a.size);
      return NULL;
    }
  }

  err_varisnotarray();
  return NULL;
}

/*
 * resize an existing array
 */
#if defined(OS_ADDR16)
void v_resize_array(var_t *v, word size)
#else
void v_resize_array(var_t *v, dword size)
#endif
{
  byte *prev;
  var_t *elem;
#if defined(OS_ADDR16)
  word i;
#else
  dword i;
#endif

  if (v->type == V_ARRAY) {
    if (size < 0) {
      err_evargerr();
      return;
    }

    if (size == 0) {
      v_free(v);
      v->type = V_ARRAY;
      v->v.a.size = 0;
      v->v.a.ptr = NULL;
      v->v.a.ubound[0] = v->v.a.lbound[0] = opt_base;
      v->v.a.maxdim = 1;
    } else if (v->v.a.size > size) {
      // resize down

      // free vars
      for (i = size; i < v->v.a.size; i++) {
        elem = (var_t *) (v->v.a.ptr + (sizeof(var_t) * i));
        v_free(elem);
      }

#if defined(OS_ADDR32)
      // do not resize array
      prev = NULL;
#else
      // resize & copy
      prev = v->v.a.ptr;
      v->v.a.ptr = tmp_alloc(size * sizeof(var_t));
      memcpy(v->v.a.ptr, prev, size * sizeof(var_t));
#endif
      // array data
      v->v.a.size = size;
      v->v.a.ubound[0] = v->v.a.lbound[0] + (size - 1);
      v->v.a.maxdim = 1;

      // 
      if (prev) {
        tmp_free(prev);
      }
    } else if (v->v.a.size < size) {
      // resize up

#if defined(OS_ADDR32)
      // if there is space do not resize 
      if (v->v.a.size == 0) {
        prev = v->v.a.ptr;
        v->v.a.ptr = tmp_alloc((size + ARR_ALLOC) * sizeof(var_t));
      } else {
        if (mem_handle_size((mem_t)v->v.a.ptr) < size * sizeof(var_t)) {
          // resize & copy
          prev = v->v.a.ptr;
          v->v.a.ptr = tmp_alloc((size + ARR_ALLOC) * sizeof(var_t));
          if (v->v.a.size > 0)
            memcpy(v->v.a.ptr, prev, v->v.a.size * sizeof(var_t));
        } else
          prev = NULL;
      }
#else
      // resize & copy
      prev = v->v.a.ptr;
      v->v.a.ptr = tmp_alloc(size * sizeof(var_t));
      if (v->v.a.size > 0) {
        memcpy(v->v.a.ptr, prev, v->v.a.size * sizeof(var_t));
      }
#endif

      // init vars
      for (i = v->v.a.size; i < size; i++) {
        elem = (var_t *) (v->v.a.ptr + (sizeof(var_t) * i));
        v_init(elem);
      }

      // array data
      v->v.a.size = size;
      v->v.a.ubound[0] = v->v.a.lbound[0] + (size - 1);
      v->v.a.maxdim = 1;

      // 
      if (prev) {
        tmp_free(prev);
      }
    }
  } else {
    err_varisnotarray();
  }
}

/*
 * create RxC array
 */
void v_tomatrix(var_t *v, int r, int c) {
  var_t *e;
  int i;

  v_free(v);
  v->type = V_ARRAY;

  // create data
  v->v.a.size = r * c;
  v->v.a.ptr = tmp_alloc(sizeof(var_t) * v->v.a.size);
  for (i = 0; i < r * c; i++) {
    e = (var_t *) (v->v.a.ptr + (sizeof(var_t) * i));
    v_init(e);
  }

  // array info
  v->v.a.lbound[0] = v->v.a.lbound[1] = opt_base;
  v->v.a.ubound[0] = opt_base + (r - 1);
  v->v.a.ubound[1] = opt_base + (c - 1);
  v->v.a.maxdim = 2;
}

/*
 * create RxC array
 */
var_t *v_new_matrix(int r, int c) {
  var_t *v;

  v = v_new();
  v_tomatrix(v, r, c);

  return v;
}

/*
 * create array
 */
#if defined(OS_ADDR16)
void v_toarray1(var_t *v, word r)
#else
void v_toarray1(var_t *v, dword r)
#endif
{
  var_t *e;
#if defined(OS_ADDR16)
  word i;
#else
  dword i;
#endif

  v_free(v);
  v->type = V_ARRAY;

  if (r > 0) {
    // create data
    v->v.a.size = r;
#if defined(OS_ADDR32)
    v->v.a.ptr = tmp_alloc(sizeof(var_t) * (v->v.a.size + ARR_ALLOC));
#else
    v->v.a.ptr = tmp_alloc(sizeof(var_t) * v->v.a.size);
#endif
    for (i = 0; i < r; i++) {
      e = (var_t *) (v->v.a.ptr + (sizeof(var_t) * i));
      v_init(e);
    }

    // array info
    v->v.a.maxdim = 1;
    v->v.a.lbound[0] = opt_base;
    v->v.a.ubound[0] = opt_base + (r - 1);
  } else {
    v->v.a.size = 0;
    v->v.a.ptr = NULL;
    v->v.a.lbound[0] = v->v.a.ubound[0] = opt_base;
    v->v.a.maxdim = 1;
  }
}

/*
 * returns true if the variable v is not empty (0 for nums)
 */
int v_is_nonzero(var_t *v) {
  switch (v->type) {
  case V_INT:
    return (v->v.i != 0);
  case V_NUM:
    // return (v->v.n != 0.0 && v->v.n != -0.0);
    return (ABS(v->v.n) > 1E-308);
  case V_STR:
    return (v->v.p.size != 0);
  case V_UDS:
    return !uds_is_empty(v);
  case V_HASH:
    return !hash_is_empty(v);
  case V_PTR:
    return (v->v.ap.p != 0);
  case V_ARRAY:
    return (v->v.a.size != 0);
  };
  return 0;
}

/*
 * compare the variable a with the variable b
 * returns
 *   -1      a < b
 *   +1      a > b
 *   0       a = b
 */
int v_compare(var_t *a, var_t *b) {
  var_num_t dt;
  var_int_t di;
  int i, ci;
  var_t *ea, *eb;

  if (a == 0 || b == 0) {
    err_evsyntax();
    return 0;
  }

  if (a->type == V_INT && b->type == V_INT) {
    di = (a->v.i - b->v.i);
    i = di < 0 ? -1 : di > 0 ? 1 : 0;
    return i;
  } else if ((a->type == V_INT || a->type == V_NUM) && (b->type == V_INT || b->type == V_NUM)) {
    var_num_t left = (a->type == V_NUM) ? a->v.n : a->v.i;
    var_num_t right = (b->type == V_NUM) ? b->v.n : b->v.i;
    dt = (left - right);
    i = dt < 0.0 ? -1 : dt > 0.0 ? 1 : 0;
    return i;
  }
  if ((a->type == V_STR) && (b->type == V_STR)) {
    return strcmp(a->v.p.ptr, b->v.p.ptr);
  }
  if ((a->type == V_STR) && (b->type == V_NUM)) {
    if (a->v.p.ptr[0] == '\0' || is_number((char *) a->v.p.ptr)) { // compare 
      // nums
      dt = v_getval(a);
      return (dt < b->v.n) ? -1 : ((dt == b->v.n) ? 0 : 1);}
return    1;
  }
  if ((a->type == V_NUM) && (b->type == V_STR)) {
    if (b->v.p.ptr[0] == '\0' || is_number((char *) b->v.p.ptr)) { // compare 
      // nums
      dt = v_getval(b);
      return (dt < a->v.n) ? 1 : ((dt == a->v.n) ? 0 : -1);}return
-    1;
  }
  if ((a->type == V_STR) && (b->type == V_INT)) {
    if (a->v.p.ptr[0] == '\0' || is_number((char *) a->v.p.ptr)) { // compare 
      // nums
      di = v_igetval(a);
      return (di < b->v.i) ? -1 : ((di == b->v.i) ? 0 : 1);}
return    1;
  }
  if ((a->type == V_INT) && (b->type == V_STR)) {
    if (b->v.p.ptr[0] == '\0' || is_number((char *) b->v.p.ptr)) { // compare 
      // nums
      di = v_igetval(b);
      return (di < a->v.i) ? 1 : ((di == a->v.i) ? 0 : -1);}return
-    1;
  }
  if ((a->type == V_ARRAY) && (b->type == V_ARRAY)) {
    // check size
    if (a->v.a.size != b->v.a.size) {
      if (a->v.a.size < b->v.a.size) {
        return -1;
      }
      return 1;
    }
    // check every element
    for (i = 0; i < a->v.a.size; i++) {
      ea = (var_t *) (a->v.a.ptr + sizeof(var_t) * i);
      eb = (var_t *) (b->v.a.ptr + sizeof(var_t) * i);
      if ((ci = v_compare(ea, eb)) != 0) {
        return ci;
      }
    }

    return 0;                   // equal
  }

  if (a->type == V_UDS && b->type == V_UDS) {
    return uds_compare(a, b);
  }

  if (a->type == V_HASH && b->type == V_HASH) {
    return hash_compare(a, b);
  }

  err_evtype();                 // ndc 01/08/2001
  return 1;
}

/*
 */
int v_addtype(var_t *a, var_t *b) {
  if (a->type == V_STR) {
    return V_STR;
  }
  if (a->type == V_NUM || b->type == V_NUM) {
    return V_NUM;
  }
  if (a->type == V_INT || b->type == V_STR) {
    return V_NUM;
  }
  return V_INT;
}

/*
 * add two variables
 * result = a + b
 */
void v_add(var_t *result, var_t *a, var_t *b) {
  char tmpsb[64];

  if (a->type == V_STR && b->type == V_STR) {
    result->type = V_STR;
    result->v.p.ptr = (byte *) tmp_alloc(strlen((char *)a->v.p.ptr) + strlen((char *)b->v.p.ptr) +
        1);
    strcpy((char *) result->v.p.ptr, (char *) a->v.p.ptr);
    strcat((char *) result->v.p.ptr, (char *) b->v.p.ptr);
    result->v.p.size = strlen((char *) result->v.p.ptr) + 1;
    return;
  } else if (a->type == V_INT && b->type == V_INT) {
    result->type = V_INT;
    result->v.i = a->v.i + b->v.i;
    return;
  } else if (a->type == V_NUM && b->type == V_NUM) {
    result->type = V_NUM;
    result->v.n = a->v.n + b->v.n;
    return;
  } else if (a->type == V_NUM && b->type == V_INT) {
    result->type = V_NUM;
    result->v.n = a->v.n + b->v.i;
    return;
  } else if (a->type == V_INT && b->type == V_NUM) {
    result->type = V_NUM;
    result->v.n = a->v.i + b->v.n;
    return;
  } else if (a->type == V_STR && (b->type == V_INT || b->type == V_NUM)) {
    if (is_number((char *) a->v.p.ptr)) {
      result->type = V_NUM;
      if (b->type == V_INT) {
        result->v.n = b->v.i + v_getval(a);
      } else {
        result->v.n = b->v.n + v_getval(a);
      }
    } else {
      result->type = V_STR;
      result->v.p.ptr = (byte *) tmp_alloc(strlen((char *)a->v.p.ptr) + 64);
      strcpy((char *) result->v.p.ptr, (char *) a->v.p.ptr);
      if (b->type == V_INT) {
        ltostr(b->v.i, tmpsb);
      } else {
        ftostr(b->v.n, tmpsb);
      }
      strcat((char *) result->v.p.ptr, tmpsb);
      result->v.p.size = strlen((char *) result->v.p.ptr) + 1;
    }
  } else if ((a->type == V_INT || a->type == V_NUM) && b->type == V_STR) {
    if (is_number((char *) b->v.p.ptr)) {
      result->type = V_NUM;
      if (a->type == V_INT
        )
        result->v.n = a->v.i + v_getval(b);
      else
        result->v.n = a->v.n + v_getval(b);
    } else {
      result->type = V_STR;
      result->v.p.ptr = (byte *) tmp_alloc(strlen((char *)b->v.p.ptr) + 64);
      if (a->type == V_INT) {
        ltostr(a->v.i, tmpsb);
      } else {
        ftostr(a->v.n, tmpsb);
      }
      strcpy((char *) result->v.p.ptr, tmpsb);
      strcat((char *) result->v.p.ptr, (char *) b->v.p.ptr);
      result->v.p.size = strlen((char *) result->v.p.ptr) + 1;
    }
  }
}

/*
 * assign (dest = src)
 */
void v_set(var_t *dest, const var_t *src) {
  int i;
  var_t *dest_vp, *src_vp;

  if (src->type == V_UDS) {
    uds_set(dest, (const var_p_t) src);
    return;
  } else if (dest->type == V_UDS) {
    // lvalue struct assigned to non-struct rvalue
    uds_clear(dest);
    return;
  } else if (src->type == V_HASH) {
    hash_set(dest, (const var_p_t) src);
    return;
  } else if (dest->type == V_HASH) {
    // lvalue struct assigned to non-struct rvalue
    hash_clear(dest);
    return;
  }

  v_free(dest);
  *dest = *src;
  dest->const_flag = 0;
  switch (src->type) {
  case V_STR:
    dest->v.p.ptr = (byte *) tmp_alloc(strlen((char *)src->v.p.ptr) + 1);
    strcpy((char *) dest->v.p.ptr, (char *) src->v.p.ptr);
    break;

  case V_ARRAY:
    if (src->v.a.size) {
      dest->v.a.ptr = tmp_alloc(src->v.a.size * sizeof(var_t));

      // copy each element
      for (i = 0; i < src->v.a.size; i++) {
        src_vp = (var_t *) (src->v.a.ptr + (sizeof(var_t) * i));
        dest_vp = (var_t *) (dest->v.a.ptr + (sizeof(var_t) * i));
        v_init(dest_vp);
        v_set(dest_vp, src_vp);
      }
    } else {
      dest->v.a.size = 0;
      dest->v.a.ptr = NULL;
      dest->v.a.ubound[0] = dest->v.a.lbound[0] = opt_base;
      dest->v.a.maxdim = 1;
    }
    break;

  case V_PTR:
    dest->v.ap = src->v.ap;
    dest->type = src->type;
    break;
  }
}

/*
 * return a full copy of the 'source'
 */
var_t *v_clone(const var_t *source) {
  var_t *vnew;

  vnew = (var_t *) tmp_alloc(sizeof(var_t));
  v_init(vnew);
  v_set(vnew, source);
  return vnew;
}

/*
 * add b to a
 */
void v_inc(var_t *a, var_t *b) {
  if (a->type == V_INT && b->type == V_INT) {
    a->v.i += b->v.i;
  } else if (a->type == V_NUM && b->type == V_NUM) {
    a->v.n += b->v.n;
  } else if (a->type == V_NUM && b->type == V_INT) {
    a->v.n += b->v.i;
  } else if (a->type == V_INT && b->type == V_NUM) {
    a->type = V_NUM;
    a->v.n = a->v.i + b->v.n;
  } else {
    err_varnotnum();
  }
}

/*
 */
int v_sign(var_t *x) {
  if (x->type == V_INT) {
    return (x->v.i < 0) ? -1 : ((x->v.i == 0) ? 0 : 1);}
else  if (x->type == V_NUM) {
    return (x->v.n < 0) ? -1 : ((x->v.n == 0) ? 0 : 1);
  }
  err_varnotnum();
  return 0;
}

/*
 * setup a string variable
 */
void v_createstr(var_t *v, const char *src) {
  int l;

  l = strlen(src) + 1;
  v->type = V_STR;
  v->v.p.ptr = tmp_alloc(l);
  v->v.p.size = l;
  strcpy(v->v.p.ptr, src);
}

/*
 * converts the variable to string-variable
 */
void v_tostr(var_t *arg) {
  if (arg->type != V_STR) {
    char *tmp;
    int l;

    tmp = tmp_alloc(64);

    switch (arg->type) {
    case V_UDS:
      uds_to_str(arg, tmp, 64);
      uds_free(arg);
      break;
    case V_HASH:
      hash_to_str(arg, tmp, 64);
      hash_free_var(arg);
      break;
    case V_PTR:
      ltostr(arg->v.ap.p, tmp);
      break;
    case V_INT:
      ltostr(arg->v.i, tmp);
      break;
    case V_NUM:
      ftostr(arg->v.n, tmp);
      break;
    default:
      err_varisarray();
      tmp_free(tmp);
      return;
    }

    l = strlen(tmp) + 1;
    arg->type = V_STR;
    arg->v.p.ptr = tmp_alloc(l);
    arg->v.p.size = l;
    strcpy(arg->v.p.ptr, tmp);
    tmp_free(tmp);
  }
}

/*
 * set the value of 'var' to string
 */
void v_setstr(var_t *var, const char *string) {
  if (var->type != V_STR || strcmp(string, var->v.p.ptr) != 0) {
    v_free(var);
    var->type = V_STR;
    var->v.p.size = strlen(string) + 1;
    var->v.p.ptr = tmp_alloc(var->v.p.size);
    strcpy(var->v.p.ptr, string);
  }
}

void v_setstrn(var_t *var, const char *string, int len) {
  if (var->type != V_STR || strncmp(string, var->v.p.ptr, len) != 0) {
    v_free(var);
    var->type = V_STR;
    var->v.p.size = len + 1;
    var->v.p.ptr = tmp_alloc(var->v.p.size);
    strncpy(var->v.p.ptr, string, len);
    var->v.p.ptr[len] = 0;
  }
}

/*
 * set the value of 'var' to string
 */
void v_setstrf(var_t *var, const char *fmt, ...) {
  char *buf;
  va_list ap;

  va_start(ap, fmt);
#if defined(OS_LIMITED)
    buf = tmp_alloc(1024);
#else
    buf = tmp_alloc(0x10000);
#endif
  vsnprintf(buf, 1024, fmt, ap);
  v_setstr(var, buf);
  tmp_free(buf);
  va_end(ap);
}

/*
 * adds a string to current string value
 */
void v_strcat(var_t *var, const char *string) {
  if (var->type == V_INT || var->type == V_NUM) {
    v_tostr(var);
  }
  if (var->type == V_STR) {
    var->v.p.size = strlen((char *) var->v.p.ptr) + strlen(string) + 1;
    var->v.p.ptr = tmp_realloc(var->v.p.ptr, var->v.p.size);
    strcat((char *) var->v.p.ptr, string);
  } else {
    err_typemismatch();
  }
}

/*
 * set the value of 'var' to n
 */
void v_setreal(var_t *var, var_num_t n) {
  v_free(var);
  var->type = V_NUM;
  var->v.n = n;
}

/*
 * set the value of 'var' to i
 */
void v_setint(var_t *var, int32 i) {
  v_free(var);
  var->type = V_INT;
  var->v.i = i;
}

/*
 * return the string value of 'var'
 */
char *v_getstr(var_t *var) {
  if (var->type != V_STR) {
    v_tostr(var);
  }
  return (char *) var->v.p.ptr;
}

/*
 * set the value of 'var' to 'itable' integer array
 */
void v_setintarray(var_t *var, int32 *itable, int count) {
  int i;
  var_t *elem_p;

  v_toarray1(var, count);
  for (i = 0; i < count; i++) {
    elem_p = (var_t *) (var->v.a.ptr + sizeof(var_t) * i);
    v_setint(elem_p, itable[i]);
  }
}

/*
 * set the value of 'var' to 'itable' real's array
 */
void v_setrealarray(var_t *var, var_num_t *ntable, int count) {
  int i;
  var_t *elem_p;

  v_toarray1(var, count);
  for (i = 0; i < count; i++) {
    elem_p = (var_t *) (var->v.a.ptr + sizeof(var_t) * i);
    v_setreal(elem_p, ntable[i]);
  }
}

/*
 * set the value of 'var' to 'itable' string array
 */
void v_setstrarray(var_t *var, char **ctable, int count) {
  int i;
  var_t *elem_p;

  v_toarray1(var, count);
  for (i = 0; i < count; i++) {
    elem_p = (var_t *) (var->v.a.ptr + sizeof(var_t) * i);
    v_setstr(elem_p, ctable[i]);
  }
}

/*
 * set an empty string
 */
void v_zerostr(var_t *r) {
  v_free(r);
  r->type = V_STR;
  r->v.p.ptr = tmp_alloc(1);
  r->v.p.ptr[0] = '\0';
  r->v.p.size = 1;
}

/*
 * convert's a user's string to variable
 *
 * its decides in what format to store the value
 * its used mostly by 'input' functions
 */
void v_input2var(const char *str, var_t *var) {
  v_free(var);

  if (strlen(str) == 0) {       // no data
    v_setstr(var, str);
  } else {
    char *np, *sb;
    char buf[64];
    int type;
    var_int_t lv;
    var_num_t dv;

    sb = tmp_strdup(str);
    np = get_numexpr(sb, buf, &type, &lv, &dv);

    if (type == 1 && *np == '\0') {
      v_setint(var, lv);
    } else if (type == 2 && *np == '\0') {
      v_setreal(var, dv);
    } else {
      v_setstr(var, str);
    }
    tmp_free(sb);
  }
}