Esempio n. 1
0
/*
 *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:
      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);
  }
}
Esempio n. 2
0
void * tmp_realloc(void * ptr, size_t size) {
    if (ptr == NULL) return tmp_alloc(size);
    assert(is_dispatch_thread());
    assert(tmp_gc_posted);
#if ENABLE_FastMemAlloc
    {
        void * p;
        size_t m = *((size_t *)ptr - 1);
        if (m >= size) return ptr;
        if ((char *)ptr >= tmp_pool && (char *)ptr <= tmp_pool + tmp_pool_max) {
            size_t pos = tmp_pool_pos - m;
            if (ptr == tmp_pool + pos && pos + size <= tmp_pool_max) {
                tmp_pool_pos = pos + size;
                *((size_t *)ptr - 1) = size;
                return ptr;
            }
        }
        p = tmp_alloc(size);
        if (m > size) m = size;
        return memcpy(p, ptr, m);
    }
#else
    {
        LINK * l = (LINK *)ptr - 1;
        list_remove(l);
        l = (LINK *)loc_realloc(l, sizeof(LINK) + size);
        list_add_last(l, &tmp_alloc_list);
        return l + 1;
    }
#endif
}
Esempio n. 3
0
/**
 * Using VMT's with keys (like environment-variables)
 *
 * sets a variable
 *
 * if varvalue == NULL, the variable will be deleted
 */
int dbt_setvar(dbt_t fh, const char *varname, const char *varvalue) {
  char *buf, *newrec = NULL;
  int i, idx;
  dbt_var_t nd, new_nd;

  if (varvalue) {
    // create the new header
    new_nd.sign = dbt_var_sign;
    new_nd.var_len = strlen(varname) + 1;
    new_nd.val_len = strlen(varvalue) + 1;
    new_nd.node_len = sizeof(new_nd) + new_nd.var_len + new_nd.val_len;

    // create record
    newrec = tmp_alloc(new_nd.node_len);
    memcpy(newrec, &new_nd, sizeof(new_nd));
    memcpy(newrec + sizeof(new_nd), varname, new_nd.var_len);
    memcpy(newrec + sizeof(new_nd) + new_nd.var_len, varvalue, new_nd.val_len);
  }

  // default index (new record)
  idx = dbt_count(fh);

  // find if already exists
  for (i = 0; i < dbt_count(fh); i++) {
    char *nd_var, *nd_val;

    // load the record
    dbt_read(fh, i, &nd, sizeof(nd));
    if (nd.sign == dbt_var_sign) {
      buf = tmp_alloc(nd.node_len);
      dbt_read(fh, i, buf, nd.node_len);
      nd_var = buf + sizeof(nd);
      nd_val = buf + sizeof(nd) + nd.var_len;

      // check varname
      if (strcmp(nd_var, varname) == 0) {
        idx = i;
        tmp_free(buf);
        break;
      }

      tmp_free(buf);
    }
  }

  if (varvalue) {
    // store the record
    dbt_write(fh, idx, newrec, new_nd.node_len);
    tmp_free(newrec);
  } else
    // delete the record
    dbt_remove(fh, idx);
  return 0;
}
Esempio n. 4
0
/*
 * 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;
  }
}
Esempio n. 5
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);
}
char *Controller::readSource(const char *fileName) {
  char *buffer = NULL;
  bool networkFile = strstr(fileName, "://");
  const char *delim = strchr(fileName, '?');
  int len = strlen(fileName);
  int endIndex = delim ? (delim - fileName) : len;
  if (delim && !networkFile) {
    strcpy(opt_command, delim + 1);
  }
  
  _mainBas = false;
  trace("readSource %s %d %s", fileName, endIndex, opt_command);

  if (networkFile) {
    buffer = readConnection(fileName);
  } else if (strncasecmp("main.bas", fileName, endIndex) == 0) {
    // load as resource
    int len = maGetDataSize(MAIN_BAS);
    buffer = (char *)tmp_alloc(len + 1);
    maReadData(MAIN_BAS, buffer, 0, len);
    buffer[len] = '\0';
    _mainBas = true;
  } else {
    // load from file system
    MAHandle handle = maFileOpen(fileName, MA_ACCESS_READ);
    if (maFileExists(handle)) {
      int len = maFileSize(handle);
      buffer = (char *)tmp_alloc(len + 1);
      maFileRead(handle, buffer, len);
      buffer[len] = '\0';
    }
    maFileClose(handle);
  }

  if (buffer == NULL) {
    buffer = (char *)tmp_alloc(strlen(ERROR_BAS) + 1);
    strcpy(buffer, ERROR_BAS);
  }

  delete [] _programSrc;
  len = strlen(buffer);
  _programSrc = new char[len + 1];
  strncpy(_programSrc, buffer, len);
  _programSrc[len] = 0;

  logPrint("Opened: %s %d bytes\n", fileName, len);
  return buffer;
}
Esempio n. 7
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;
}
Esempio n. 8
0
/**
 * Using VMT's with keys (like environment-variables)
 *
 * gets a variable's value
 * if variable not found, returns NULL otherwise returns a newly created string with the value
 */
char *dbt_getvar(dbt_t fh, const char *varname) {
  char *buf, *retval = NULL;
  int i;
  dbt_var_t nd;

  // find if already exists
  for (i = 0; i < dbt_count(fh); i++) {
    char *nd_var, *nd_val;

    // load the record
    dbt_read(fh, i, &nd, sizeof(nd));
    if (nd.sign == dbt_var_sign) {
      buf = tmp_alloc(nd.node_len);
      dbt_read(fh, i, buf, nd.node_len);
      nd_var = buf + sizeof(nd);
      nd_val = buf + sizeof(nd) + nd.var_len;

      // check varname
      if (strcmp(nd_var, varname) == 0) {
        retval = tmp_strdup(nd_val);
        tmp_free(buf);
        break;
      }

      tmp_free(buf);
    }
  }

  return retval;
}
Esempio n. 9
0
/**
 * allocates additional space on database for 'recs' records of 'recsize' size
 */
int dbt_file_append(dbt_t t, int recs, int recsize) {
  vmt_rec_t rec;
  int i;
  int n;

  rec.ver = 1;
  rec.size = recsize;

  // create empty records
  if (vmt[t].count + recs >= vmt[t].size) {
    int newsize;
    char *data;

    data = tmp_alloc(recsize);
    memset(data, 0, recsize);
    newsize = vmt[t].size + recs;

    for (i = vmt[t].size; i < newsize; i++) {
      lseek(vmt[t].i_handle, sizeof(vmt_rec_t) * i + sizeof(vmt_t), SEEK_SET);
      rec.offset = lseek(vmt[t].f_handle, 0, SEEK_END);
      n = write(vmt[t].i_handle, &rec, sizeof(vmt_rec_t));
      n = write(vmt[t].f_handle, data, recsize);
    }

    tmp_free(data);
    vmt[t].size = newsize;
  }

  vmt[t].count++;

  // 
  dbt_file_write_header(t);
  return vmt[t].count - 1;
}
Esempio n. 10
0
/*
 * Set the environment variable "name" to the value "value". If the variable
 * exists already, override it or just skip.
 */
static void envp_add(char *** envp, const char * name, const char * value, int env_override) {
    int i = 0;
    size_t len = strlen(name);
    char ** env = *envp;

    assert(name);
    assert(value);

    if (env == NULL) {
        env = *envp = (char **)tmp_alloc_zero(sizeof(char *) * 2);
    }
    else {
        for (i = 0; env[i]; i++) {
            if (strncmp(env[i], name, len) == 0 && env[i][len] == '=') break;
        }
        if (env[i]) {
            /* override */
            if (!env_override) return;
        }
        else {
            /* new variable */
            env = *envp = (char **)tmp_realloc(env, sizeof(char *) * (i + 2));
            env[i + 1] = NULL;
        }
    }
    len += strlen(value) + 2;
    env[i] = (char *)tmp_alloc(len);
    snprintf(env[i], len, "%s=%s", name, value);
}
Esempio n. 11
0
static void read_field(Context * ctx, const Symbol * sym, ContextAddress base, ContextAddress * value) {
    LocationInfo * loc_info = NULL;
    LocationExpressionState * state = NULL;
    uint64_t args[1];
    void * buf = NULL;
    size_t size = 0;
    size_t i;

    args[0] = base;
    if (get_location_info(sym, &loc_info) < 0) exception(errno);
    if (loc_info->args_cnt != 1) str_exception(ERR_OTHER, "Wrong object kind");
    state = evaluate_location_expression(ctx, NULL,
                                         loc_info->value_cmds.cmds, loc_info->value_cmds.cnt, args, 1);
    if (state->pieces_cnt > 0) {
        read_location_pieces(state->ctx, state->stack_frame,
                             state->pieces, state->pieces_cnt, loc_info->big_endian, &buf, &size);
    }
    else {
        ContextAddress sym_size = 0;
        if (state->stk_pos != 1) str_exception(ERR_OTHER, "Invalid location expression");
        if (get_symbol_size(sym, &sym_size) < 0) exception(errno);
        size = (size_t)sym_size;
        buf = tmp_alloc(size);
        if (context_read_mem(state->ctx, (ContextAddress)state->stk[0], buf, size) < 0) exception(errno);
    }
    *value = 0;
    for (i = 0; i < size && i < sizeof(ContextAddress); i++) {
        *value = *value << 8;
        *value |= ((uint8_t *)buf)[loc_info->big_endian ? i : size - i - 1];
    }
}
Esempio n. 12
0
void v_setstr(var_t *var, const char *string) {
  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);
}
Esempio n. 13
0
static void address_to_line_cb(CodeArea * area, void * args) {
    CodeArea ** p = (CodeArea **)args;
    if (*p == NULL || (*p)->start_address < area->start_address) {
        *p = (CodeArea *)tmp_alloc(sizeof(CodeArea));
        **p = *area;
    }
}
Esempio n. 14
0
/*
 * 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;
}
Esempio n. 15
0
/*
 * 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;
}
Esempio n. 16
0
char * tmp_strdup2(const char * s1, const char * s2) {
    size_t l1 = strlen(s1);
    size_t l2 = strlen(s2);
    char * rval = (char *)tmp_alloc(l1 + l2 + 1);
    memcpy(rval, s1, l1);
    memcpy(rval + l1, s2, l2 + 1);
    return rval;
}
Esempio n. 17
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);
}
Esempio n. 18
0
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;
  }
}
Esempio n. 19
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);
  buf = tmp_alloc(1024);
  vsnprintf(buf, 1024, fmt, ap);
  v_setstr(var, buf);
  tmp_free(buf);
  va_end(ap);
}
Esempio n. 20
0
/*
 * add format node
 */
void fmt_addfmt(const char *fmt, int type) {
  fmt_node_t *node;

  node = &fmt_stack[fmt_count];
  fmt_count++;
  if (fmt_count >= MAX_FMT_N) {
    panic("Maximum format-node reached");
  }
  node->fmt = tmp_alloc(strlen(fmt) + 1);
  strcpy(node->fmt, fmt);
  node->type = type;
}
Esempio n. 21
0
/*
 * 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);
  }
}
Esempio n. 22
0
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;
  }
}
Esempio n. 23
0
/*
 *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;
}
Esempio n. 24
0
/**
 * removes deleted chuncks (defrag)
 */
void dbt_file_pack(dbt_t t) {
  vmt_rec_t rec;
  int i, idx_offset, new_h, new_offset, n;
  char *data;
  char old_db_name[OS_PATHNAME_SIZE];
  char new_db_name[OS_PATHNAME_SIZE];

  sprintf(old_db_name, "%s.dbt", vmt[t].base);
  sprintf(new_db_name, "%s-new.dbt", vmt[t].base);
  new_h = open(new_db_name, O_BINARY | O_RDWR);
  for (i = 0; i < vmt[t].size; i++) {
    // read original record data
    idx_offset = i * sizeof(vmt_rec_t) + sizeof(vmt_t);
    lseek(vmt[t].i_handle, idx_offset, SEEK_SET);

    // read data
    data = tmp_alloc(rec.size);
    lseek(vmt[t].f_handle, rec.offset, rec.size);
    n = read(vmt[t].f_handle, data, rec.size);

    // copy record
    new_offset = lseek(new_h, 0, SEEK_END);
    rec.offset = new_offset;
    n = write(new_h, data, rec.size);
    tmp_free(data);

    // update index
    n = write(vmt[t].i_handle, &rec, sizeof(vmt_rec_t));
  }

  // swap databases and reopen
  close(vmt[t].f_handle);
  remove(old_db_name);
  close(new_h);
  rename(new_db_name, old_db_name);
  vmt[t].f_handle = open(old_db_name, O_BINARY | O_RDWR);
}
Esempio n. 25
0
/*
 * format: format a number
 *
 * symbols:
 *   # = digit or space
 *   0 = digit or zero
 *   ^ = exponential digit/format
 *   . = decimal point
 *   , = thousands
 *   - = minus for negative
 *   + = sign of number
 */
void format_num(char *dest, const char *fmt_cnst, var_num_t x) {
  char *p, *fmt;
  char left[64], right[64];
  char lbuf[64], rbuf[64];
  int dp = 0, lc = 0, sign = 0;
  int rsz, lsz;

  // backup of format
  fmt = tmp_alloc(strlen(fmt_cnst) + 1);
  strcpy(fmt, fmt_cnst);

  // check sign
  if (strchr(fmt, '-') || strchr(fmt, '+')) {
    sign = 1;
    if (x < 0.0) {
      sign = -1;
      x = -x;
    }
  }

  if (strchr(fmt_cnst, '^')) {
    // 
    // E format
    // 

    lc = fmt_cdig(fmt);
    if (lc < 4) {
      fmt_omap(dest, fmt);
      tmp_free(fmt);
      return;
    }

    // convert
    expfta(x, dest);

    // format
    p = strchr(dest, 'E');
    if (p) {
      *p = '\0';
      strcpy(left, dest);
      strcpy(right, p + 1);
      lsz = strlen(left);
      rsz = strlen(right) + 1;

      if (lc < rsz + 1) {
        fmt_omap(dest, fmt);
        tmp_free(fmt);
        return;
      }

      if (lc < lsz + rsz + 1)
        left[lc - rsz] = '\0';

      strcpy(lbuf, left);
      strcat(lbuf, "E");
      strcat(lbuf, right);
      fmt_nmap(-1, dest, fmt, lbuf);
    } else {
      strcpy(left, dest);
      fmt_nmap(-1, dest, fmt, left);
    }
  } else {
    // 
    // normal format
    // 

    // rounding
    p = strchr(fmt, '.');
    if (p) {
      x = fround(x, fmt_cdig(p + 1));
    } else {
      x = fround(x, 0);
    }

    // convert
    bestfta(x, dest);
    if (strchr(dest, 'E')) {
      fmt_omap(dest, fmt);
      tmp_free(fmt);
      return;
    }

    // left & right parts
    left[0] = right[0] = '\0';
    p = strchr(dest, '.');
    if (p) {
      *p = '\0';
      strcpy(right, p + 1);
    }
    strcpy(left, dest);

    // map format
    rbuf[0] = lbuf[0] = '\0';
    p = strchr(fmt, '.');
    if (p) {
      dp = 1;
      *p = '\0';
      fmt_nmap(1, rbuf, p + 1, right);
    }

    lc = fmt_cdig(fmt);
    if (lc < strlen(left)) {
      fmt_omap(dest, fmt_cnst);
      tmp_free(fmt);
      return;
    }
    fmt_nmap(-1, lbuf, fmt, left);

    strcpy(dest, lbuf);
    if (dp) {
      strcat(dest, ".");
      strcat(dest, rbuf);
    }
  }

  // sign in format
  if (sign) {                   // 24/6 Snoopy42 modifications
    char *e;

    e = strchr(dest, 'E');
    if (e) {                    // special treatment for E format 
      p = strchr(dest, '+');
      if (p && p < e) {          // the sign bust be before the E 
        *p = (sign > 0) ? '+' : '-';
      }
      p = strchr(dest, '-');
      if (p && p < e) {
        *p = (sign > 0) ? ' ' : '-';
      }
    } else {                      // no E format 
      p = strchr(dest, '+');
      if (p) {
        *p = (sign > 0) ? '+' : '-';
      }
      p = strchr(dest, '-');
      if (p) {
        *p = (sign > 0) ? ' ' : '-';
      }
    }
  }

  // cleanup
  tmp_free(fmt);
}
Esempio n. 26
0
void InitEMalloc()
/* initialize storage allocator */
{
    int i, j, p;
#ifdef ELINUX
    pagesize = getpagesize();
#else
    eu_dll_exists = (Argc == 0);  // Argc is 0 only in Euphoria .dll
    pool[0].size = 8;
    pool[0].first = NULL;
    p = RESOLUTION * 2;
    for (i = 1; i < NUMBER_OF_SIZES; i = i + 2) {
	pool[i].size = p;
	pool[i].first = NULL;
	if (i+1 < NUMBER_OF_SIZES) {
	    pool[i+1].size = 3 * p / 2;
	    pool[i+1].first = NULL;
	    p = p * 2;
	}
    }
    j = 0;
    for (i = 0; i <= MAX_CACHED_SIZE / RESOLUTION; i++) {
	if (pool[j].size < i * RESOLUTION)
	    j++;
	pool_map[i] = &pool[j];
    }
#endif
    call_back_arg1 = tmp_alloc();
    call_back_arg1->mode = M_TEMP;
    call_back_arg1->obj = NOVALUE;

    call_back_arg2 = tmp_alloc();
    call_back_arg2->mode = M_TEMP;
    call_back_arg2->obj = NOVALUE;

    call_back_arg3 = tmp_alloc();
    call_back_arg3->mode = M_TEMP;
    call_back_arg3->obj = NOVALUE;

    call_back_arg4 = tmp_alloc();
    call_back_arg4->mode = M_TEMP;
    call_back_arg4->obj = NOVALUE;

    call_back_arg5 = tmp_alloc();
    call_back_arg5->mode = M_TEMP;
    call_back_arg5->obj = NOVALUE;

    call_back_arg6 = tmp_alloc();
    call_back_arg6->mode = M_TEMP;
    call_back_arg6->obj = NOVALUE;

    call_back_arg7 = tmp_alloc();
    call_back_arg7->mode = M_TEMP;
    call_back_arg7->obj = NOVALUE;

    call_back_arg8 = tmp_alloc();
    call_back_arg8->mode = M_TEMP;
    call_back_arg8->obj = NOVALUE;

    call_back_arg9 = tmp_alloc();
    call_back_arg9->mode = M_TEMP;
    call_back_arg9->obj = NOVALUE;

    call_back_result = tmp_alloc();
    call_back_result->mode = M_TEMP;
    call_back_result->obj = NOVALUE;
}
Esempio n. 27
0
/*
 * The final format - create the format-list 
 * (that list it will be used later by fmt_printN and fmt_printS)
 *
 * '_' the next character is not belongs to format (simple string)
 */
void build_format(const char *fmt_cnst) {
  char *fmt;
  char *p;
  int nc;
#if     defined(OS_LIMITED)
  char buf[128], *b;
#else
  char buf[1024], *b;
#endif

  free_format();

  // backup of format
  fmt = tmp_alloc(strlen(fmt_cnst) + 1);
  strcpy(fmt, fmt_cnst);

  p = fmt;
  b = buf;
  nc = 0;
  while (*p) {
    switch (*p) {
    case '_':
      // store prev. buf
      *b = '\0';
      if (strlen(buf)) {
        fmt_addfmt(buf, 0);
      }
      // store the new
      buf[0] = *(p + 1);
      buf[1] = '\0';
      fmt_addfmt(buf, 0);
      b = buf;
      p++;
      break;
    case '-':
    case '+':
    case '^':
    case '0':
    case '#':
      // store prev. buf
      *b = '\0';
      if (strlen(buf)) {
        fmt_addfmt(buf, 0);
      }
      // get num-fmt
      p = fmt_getnumfmt(buf, p);
      fmt_addfmt(buf, 1);
      b = buf;
      nc = 1;
      break;
    case '&':
    case '!':
    case '\\':
      // store prev. buf
      *b = '\0';
      if (strlen(buf)) {
        fmt_addfmt(buf, 0);
      }
      // get str-fmt
      p = fmt_getstrfmt(buf, p);
      fmt_addfmt(buf, 2);
      b = buf;
      nc = 1;
      break;
    default:
      *b++ = *p;
    }

    if (*p) {
      if (nc) {                  // do not advance
        nc = 0;
      } else {
        p++;
      }
    }
  }

  // store prev. buf
  *b = '\0';
  if (strlen(buf)) {
    fmt_addfmt(buf, 0);
  }
  // cleanup
  tmp_free(fmt);
}
Esempio n. 28
0
// returns the contents of the given url
char *Controller::readConnection(const char *url) {
  char *result = NULL;
  logEntered();
  _output->print("\033[ LLoading...");

  MAHandle conn = maConnect(url);
  if (conn < 1) {
    logPrint("Failed connecting to %s\n", url);
  } else {
    _runMode = conn_state;
    logPrint("Connecting to %s\n", url);

    bool connected = false;
    byte buffer[1024];
    int length = 0;
    int size = 0;
    int now = maGetMilliSecondCount();
    MAEvent event;

    // pause until connected
    while (_runMode == conn_state) {
      event = processEvents(EVENT_WAIT_INFINITE, EVENT_TYPE_CONN);
      if (event.type == EVENT_TYPE_CONN) {
        switch (event.conn.opType) {
        case CONNOP_CONNECT:
          // connection established
          if (!connected) {
            connected = (event.conn.result > 0);
            if (connected) {
              memset(buffer, 0, sizeof(buffer));
              maConnRead(conn, buffer, sizeof(buffer));
            } else {
              logPrint("Connection error\n");
              _runMode = init_state;
            }
          }
          break;
        case CONNOP_READ:
          // connRead completed
          if (event.conn.result > 0) {
            size = event.conn.result;
            if (result == NULL) {
              result = (char *)tmp_alloc(size + 1);
              memcpy(result, buffer, size);
              length = size;
            } else {
              result = (char *)tmp_realloc(result, length + size + 1);
              memcpy(result + length, buffer, size);
              length += size;
            }
            result[length] = 0;
            memset(buffer, 0, sizeof(buffer));
            maConnRead(conn, buffer, sizeof(buffer));
          } else {
            // no more data
            _runMode = init_state;
          }
          break;
        default:
          logPrint("Connection error\n");
          _runMode = init_state;
        }
      }
    }
    logPrint("Loaded in %d msecs\n", maGetMilliSecondCount() - now);
  }

  maConnClose(conn);
  return result;
}
Esempio n. 29
0
static void safe_memory_fill(void * parm) {
    MemoryCommandArgs * args = (MemoryCommandArgs *)parm;
    Channel * c = args->c;
    Context * ctx = args->ctx;

    if (!is_channel_closed(c)) {
        Trap trap;
        if (set_trap(&trap)) {
            InputStream * inp = &c->inp;
            OutputStream * out = &c->out;
            char * token = args->token;
            ContextAddress addr0 = args->addr;
            ContextAddress addr = args->addr;
            unsigned long size = args->size;
            MemoryErrorInfo err_info;
            MemoryFillBuffer buf;
            char * tmp = NULL;
            int err = 0;

            memset(&err_info, 0, sizeof(err_info));
            if (ctx->exiting || ctx->exited) err = ERR_ALREADY_EXITED;

            memset(&buf, 0, sizeof(buf));
            buf.buf = (char *)tmp_alloc(buf.max = BUF_SIZE);

            if (err) json_skip_object(inp);
            else json_read_array(inp, read_memory_fill_array_cb, &buf);
            json_test_char(inp, MARKER_EOA);
            json_test_char(inp, MARKER_EOM);

            while (err == 0 && buf.pos < size && buf.pos <= buf.max / 2) {
                if (buf.pos == 0) {
                    buf.buf[buf.pos++] = 0;
                }
                else {
                    memcpy(buf.buf + buf.pos, buf.buf, buf.pos);
                    buf.pos *= 2;
                }
            }

            while (err == 0 && addr < addr0 + size) {
                /* Note: context_write_mem() modifies buffer contents */
                unsigned wr = (unsigned)(addr0 + size - addr);
                if (tmp == NULL) tmp = (char *)tmp_alloc(buf.pos);
                if (wr > buf.pos) wr = buf.pos;
                /* TODO: word size, mode */
                memcpy(tmp, buf.buf, wr);
                if (context_write_mem(ctx, addr, tmp, wr) < 0) {
                    err = errno;
#if ENABLE_ExtendedMemoryErrorReports
                    context_get_mem_error_info(&err_info);
#endif
                }
                else {
                    addr += wr;
                }
            }

            send_event_memory_changed(ctx, addr0, size);

            write_stringz(out, "R");
            write_stringz(out, token);
            write_errno(out, err);
            if (err == 0) {
                write_stringz(out, "null");
            }
            else {
                write_ranges(out, addr0, (int)(addr - addr0), BYTE_CANNOT_WRITE, &err_info);
            }
            write_stream(out, MARKER_EOM);
            clear_trap(&trap);
        }
        else {
            trace(LOG_ALWAYS, "Exception in Memory.fill: %s", errno_to_str(trap.error));
            channel_close(c);
        }
    }
    channel_unlock(c);
    context_unlock(ctx);
    loc_free(args);
}
Esempio n. 30
0
/*
 * 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;
    }
  }
}