C++ (Cpp) err_evargerr Exemples

Exemple #1

/*
 * resize an existing array
 */
void v_resize_array(var_t *v, dword size) {
  if (v->type == V_ARRAY) {
    if ((int)size < 0) {
      err_evargerr();
      return;
    }
    int i;
    if (size == 0) {
      v_free(v);
      v->type = V_ARRAY;
      v->v.a.size = 0;
      v->v.a.data = 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++) {
        var_t *elem = v_elem(v, i);
        v_free(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;
    } else if (v->v.a.size < size) {
      // resize up, if there is space do not resize
      int prev_size = v->v.a.size;
      if (prev_size == 0) {
        v_new_array(v, size);
      } else if (prev_size < size) {
        // resize & copy
        v->v.a.data = (var_t *)realloc(v->v.a.data, sizeof(var_t) * size);
        v->v.a.size = size;
      }

      // init vars
      for (i = prev_size; i < size; i++) {
        var_t *elem = v_elem(v, 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;
    }
  } else {
    err_varisnotarray();
  }
}

Exemple #2

Fichier : var.c Projet : bihai/SmallBASIC

/*
 * resize an existing array
 */
void v_resize_array(var_t *v, dword size) {
  byte *prev;
  var_t *elem;
  dword i;

  if (v->type == V_ARRAY) {
    if ((int)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);
      }

      // do not resize array
      prev = NULL;

      // 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) {
        free(prev);
      }
    } else if (v->v.a.size < size) {
      // resize up
      // if there is space do not resize
      if (v->v.a.size == 0) {
        prev = v->v.a.ptr;
        v->v.a.ptr = malloc((size + ARR_ALLOC) * sizeof(var_t));
      } else {
        if (v->v.a.size < size) {
          // resize & copy
          prev = v->v.a.ptr;
          v->v.a.ptr = malloc((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;
        }
      }

      // 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) {
        free(prev);
      }
    }
  } else {
    err_varisnotarray();
  }
}

Exemple #3

Fichier : var.c Projet : sanyaade-teachings/SmallBASIC

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(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();
  }
}