Пример #1
0
int crm114__list_read(SparseElementList *l, FILE *fp, int n_elts) {
  SparseNode n, pn;
  int i;
  size_t unused;

  if (!l || !fp || n_elts < 0) {
    if (CRM114__MATR_DEBUG_MODE) {
      fprintf(stderr, "crm114__list_write: null arguments.\n");
    }
    return 0;
  }

  if (!crm114__list_is_empty(l)) {
    crm114__list_clear(l);
  }

  l->last_addr = NULL;

  unused = fread(l, sizeof(SparseElementList), 1, fp);
  if (n_elts <= 0) {
    return 0;
  }
  l->head = node_read(l->compact, fp);
  pn = l->head;
  for (i = 1; i < n_elts; i++) {
    if (null_node(pn)) {
      break;
    }
    n = node_read(l->compact, fp);
    if (null_node(n)) {
      break;
    }
    if (l->compact) {
      pn.compact->next = n.compact;
      n.compact->prev = pn.compact;
    } else {
      pn.precise->next = n.precise;
      n.precise->prev = pn.precise;
    }
    pn = n;
  }
  if (i != n_elts) {
    if (!null_node(pn)) {
      if (l->compact) {
	pn.compact->next = NULL;
      } else {
	pn.precise->next = NULL;
      }
    }
    if (CRM114__MATR_DEBUG_MODE) {
      fprintf(stderr, "crm114__list_read: Couldn't read in enough elements.\n");
    }
  }
  l->tail = pn;
  return i;
}
Пример #2
0
node_t*test_serialization(node_t*node)
{
    writer_t *w = growingmemwriter_new();
    node_write(node, w, 0);
    node_destroy(node);
    reader_t*r = growingmemwriter_getreader(w);
    w->finish(w);
    node = node_read(r);
    r->dealloc(r);
    return node;
}
Пример #3
0
void node_tick(Node *n) {
  n->blocked = TRUE;

  Instruction *i = &n->instructions[n->ip];
  short tmp;
  ReadResult read;

  int blocked;

  switch(i->operation) {
    case MOV:
      read = node_read(n, i->src_type, i->src);
      if (read.blocked) return;
      blocked = node_write(n, i->dest.direction, read.value);
      if (blocked) return;
      break;
    case ADD:
      read = node_read(n, i->src_type, i->src);
      if (read.blocked) return;

      n->acc += read.value;
      if (n->acc > MAX_ACC) n->acc = MAX_ACC;
      if (n->acc < MIN_ACC) n->acc = MIN_ACC;
      break;
    case SUB:
      read = node_read(n, i->src_type, i->src);
      if (read.blocked) return;

      n->acc -= read.value;
      if (n->acc > MAX_ACC) n->acc = MAX_ACC;
      if (n->acc < MIN_ACC) n->acc = MIN_ACC;
      break;
    case JMP: node_set_ip(n, i->src.number); return;
    case JRO: node_set_ip(n, n->ip + i->src.number); return;
    case JEZ:
      if (n->acc == 0) {
        node_set_ip(n, i->src.number);
        return;
      }
      break;
    case JGZ:
      if (n->acc > 0) {
        node_set_ip(n, i->src.number);
        return;
      }
      break;
    case JLZ:
      if (n->acc < 0) {
        node_set_ip(n, i->src.number);
        return;
      }
      break;
    case JNZ:
      if (n->acc != 0) {
        node_set_ip(n, i->src.number);
        return;
      }
      break;
    case SWP:
      tmp = n->bak;
      n->bak = n->acc;
      n->acc = tmp;
      break;
    case SAV: n->bak = n->acc; break;
    case NEG: n->acc = n->acc * -1; break;
    case NOP: break;
    case OUT:
#ifndef RICH_OUTPUT
      printf("%d\n", n->acc);
#endif
      break;
    default:
      raise_error("ERROR: DIDN'T HANDLE op\n");
  }
  n->blocked = FALSE;
  node_advance(n);
}