Пример #1
0
/* open scratch buffer; initialize line queue */
bool init_buffers( void )
  {
  /* Read stdin one character at a time to avoid i/o contention
     with shell escapes invoked by nonterminal input, e.g.,
     ed - <<EOF
     !cat
     hello, world
     EOF */
  setvbuf( stdin, 0, _IONBF, 0 );
  if( !open_sbuf() ) return false;
  link_nodes( &buffer_head, &buffer_head );
  link_nodes( &yank_buffer_head, &yank_buffer_head );
  return true;
  }
Пример #2
0
// Consolidate a queue in amortized O(log n)
static 
void consolidate_queue(priority_queue* q) {
  unsigned int length = q->length;
  
  unsigned int array_size = 2 * log(length) / log(2) + 1;
  priority_node* tree_by_degree[array_size]; // TODO: We need only 2log n entries
  unsigned int i;
  for (i=0; i<array_size; i++)
    tree_by_degree[i] = NULL;

  priority_node* n = NULL;
  while (((n = delete_first(q)))) {
    priority_node* n1 = NULL;
    while (((n1 = tree_by_degree[n->degree]))) {
      tree_by_degree[n->degree] = NULL;
      n = link_nodes(q, n, n1);
    }
    tree_by_degree[n->degree] = n;
  }

  // Find minimum value in O(log n) // Only if we shorten the array
  q->rootlist = NULL;
  q->min = NULL;
  for (i=0; i<array_size; i++) {    
    if (tree_by_degree[i] != NULL) {
      meld_queue(q, tree_by_degree[i], 0);
    }
  }

  q->length = length;
}
Пример #3
0
void nodes::set_nodes(int part_)
{
	if (part_ == 0)
	{
		//type 0 = nodo rojo, 1 nodo azul, 2 estacion espacial
		Node* n1 = add_new_node(2,184,311);
		Node* n2 = add_new_node(0,167,157,n1);
		Node* n3 = add_new_node(0,348,53,n2);
		Node* n4 = add_new_node(0,348,259,n2);
		Node* n5 = add_new_node(0,450,157,n4);
		link_nodes(n5,n3);
		Node* n6 = add_new_node(0,638,107,n5);
		//Node* n7 = add_new_node(0,885,58,n6);
		//Node* n8 = add_new_node(0,845,345,n6);
		//Node* n9 = add_new_node(0,597,542,n8);
		//Node* n10 = add_new_node(0,807,536,n6);
		//Node* n11 = add_new_node(0,475,280,n9);
		Node* n12 = add_new_node(0,426,590,n6);
		Node* n13 = add_new_node(0,278,439,n12);
		Node* n14 = add_new_node(0,76,568,n13);

		//std::vector<CL_Vec2f> res = aStarNodeVersion(n5,n1);

		spaceships_.push_back(spaceship());
		main_station_node_ = n1;
		spaceships_[0].set_current_pos(main_station_node_);
		//spaceships_[0].create_path(n9);
	}
}
Пример #4
0
/* move a range of lines */
bool move_lines( const int first_addr, const int second_addr, const int addr,
                 const bool isglobal )
  {
  line_t *b1, *a1, *b2, *a2;
  int n = inc_addr( second_addr );
  int p = first_addr - 1;

  disable_interrupts();
  if( addr == first_addr - 1 || addr == second_addr )
    {
    a2 = search_line_node( n );
    b2 = search_line_node( p );
    current_addr_ = second_addr;
    }
  else if( !push_undo_atom( UMOV, p, n ) ||
           !push_undo_atom( UMOV, addr, inc_addr( addr ) ) )
    { enable_interrupts(); return false; }
  else
    {
    a1 = search_line_node( n );
    if( addr < first_addr )
      {
      b1 = search_line_node( p );
      b2 = search_line_node( addr );	/* this search_line_node last! */
      }
    else
      {
      b2 = search_line_node( addr );
      b1 = search_line_node( p );	/* this search_line_node last! */
      }
    a2 = b2->q_forw;
    link_nodes( b2, b1->q_forw );
    link_nodes( a1->q_back, a2 );
    link_nodes( b1, a1 );
    current_addr_ = addr + ( ( addr < first_addr ) ?
                           second_addr - first_addr + 1 : 0 );
    }
  if( isglobal ) unset_active_nodes( b2->q_forw, a2 );
  modified_ = true;
  enable_interrupts();
  return true;
  }
Пример #5
0
	/** Consolidates heap */
	void consolidate()
	{
		fibonacci_heap_node *x, *y, *w;
		int d;

		for(int i = 0; i < Dn; i++)
		{
			A[i] = NULL;
		}

		min_root->left->right = NULL;
		min_root->left = NULL;
		w = min_root;

		do
		{
			x = w;
			d = x->rank;
			w = w->right;

			while(A[d] != NULL)
			{
				y = A[d];

				if(y->key < x->key)
				{
					fibonacci_heap_node *temp;

					temp = y;
					y = x;
					x = temp;
				}

				link_nodes(y, x);

				A[d] = NULL;
				d++;
			}
			A[d] = x;
		}
		while(w != NULL);

		min_root = NULL;
		num_trees = 0;

		for(int i = 0; i < Dn; i++)
		{
			if(A[i] != NULL)
			{
				A[i]->marked = false;
				add_to_roots(A[i]);
			}
		}
	}
Пример #6
0
static void clear_yank_buffer( void )
  {
  line_t * lp = yank_buffer_head.q_forw;

  disable_interrupts();
  while( lp != &yank_buffer_head )
    {
    line_t * const p = lp->q_forw;
    link_nodes( lp->q_back, lp->q_forw );
    free( lp );
    lp = p;
    }
  enable_interrupts();
  }
Пример #7
0
result_t insert_at_end(list_t *list, data_t data)
{
	node_t *last_node, *new_node;

	if(NULL_CHECK(list))
	{
		return (ERROR);
	}

	last_node = get_last_node(list); 
	new_node = get_node(data);
	
	link_nodes(last_node, new_node);

	return (SUCCESS);
}
Пример #8
0
result_t insert_at_begin(list_t *list, data_t data)
{
	node_t *head, *new_node;
	
	if(NULL_CHECK(list))
	{
		return (ERROR);
	}

	head = list;
	new_node = get_node(data);

	link_nodes(head, new_node);

	return (SUCCESS);
}
Пример #9
0
/* delete a range of lines */
bool delete_lines( const int from, const int to, const bool isglobal )
  {
  line_t *n, *p;

  if( !yank_lines( from, to ) ) return false;
  disable_interrupts();
  if( !push_undo_atom( UDEL, from, to ) )
    { enable_interrupts(); return false; }
  n = search_line_node( inc_addr( to ) );
  p = search_line_node( from - 1 );	/* this search_line_node last! */
  if( isglobal ) unset_active_nodes( p->q_forw, n );
  link_nodes( p, n );
  last_addr_ -= to - from + 1;
  current_addr_ = from - 1;
  modified_ = true;
  enable_interrupts();
  return true;
  }
Пример #10
0
Файл: main.c Проект: DarylX/4061
int read_file(FILE * file, node_t * array[], int max_nodes) {
	char line[max_nodes];
	int count = 0;
    
	while (fgets(line, MAX_LENGTH, file)) {
        node_t * node = (node_t*)malloc(sizeof(node_t));
        //parse node and check that it was properly created
        if(parse_input_line(line, count, node) == 1){
            array[count] = node;
			count++;
        } else {
            perror("Could not produce node from line");
            return -1;
        }
	}
	link_nodes(array, count);
	return count;
}
Пример #11
0
// link two binomial heaps
static 
  priority_node* link_nodes(priority_queue* q, priority_node* b1, priority_node* b2) {
    if (q->compare_function(b2->priority, b1->priority) < 0)
      return link_nodes(q, b2, b1);
    b2->parent = b1;
    priority_node* child = b1->child;
    b1->child = b2;
    if (child) {
      b2->left  = child->left;
      b2->left->right = b2;
      b2->right = child;
      b2->right->left = b2;
    } else {
      b2->left = b2;
      b2->right = b2;
    }
    b1->degree++;
    b2->mark = false;
    return b1;
  }
Пример #12
0
result_t insert_before_data(list_t *list, data_t search_key, data_t insert_key)
{
	node_t *target;

	if(NULL_CHECK(list))
	{
		return (ERROR);
	}

	target = search_node(list, search_key);
	if(target != NULL)
	{
		link_nodes(target -> prev, get_node(insert_key));
		return (SUCCESS);
	} 
	else 
	{
		return (ERROR);
	}
}
Пример #13
0
/* undo last change to the editor buffer */
bool undo( const bool isglobal )
  {
  int n;
  const int o_current_addr = current_addr_;
  const int o_last_addr = last_addr_;
  const bool o_modified = modified_;

  if( u_ptr <= 0 || u_current_addr < 0 || u_last_addr < 0 )
    { set_error_msg( "Nothing to undo" ); return false; }
  search_line_node( 0 );		/* reset cached value */
  disable_interrupts();
  for( n = u_ptr - 1; n >= 0; --n )
    {
    switch( ustack[n].type )
      {
      case UADD: link_nodes( ustack[n].head->q_back, ustack[n].tail->q_forw );
                 break;
      case UDEL: link_nodes( ustack[n].head->q_back, ustack[n].head );
                 link_nodes( ustack[n].tail, ustack[n].tail->q_forw );
                 break;
      case UMOV:
      case VMOV: link_nodes( ustack[n-1].head, ustack[n].head->q_forw );
                 link_nodes( ustack[n].tail->q_back, ustack[n-1].tail );
                 link_nodes( ustack[n].head, ustack[n].tail ); --n;
                 break;
      }
    ustack[n].type ^= 1;
    }
  /* reverse undo stack order */
  for( n = 0; 2 * n < u_ptr - 1; ++n )
    {
    undo_t tmp = ustack[n];
    ustack[n] = ustack[u_ptr-1-n]; ustack[u_ptr-1-n] = tmp;
    }
  if( isglobal ) clear_active_list();
  current_addr_ = u_current_addr; u_current_addr = o_current_addr;
  last_addr_ = u_last_addr; u_last_addr = o_last_addr;
  modified_ = u_modified; u_modified = o_modified;
  enable_interrupts();
  return true;
  }
Пример #14
0
/* insert line node into circular queue after previous */
static void insert_node( line_t * const lp, line_t * const prev )
  {
  link_nodes( lp, prev->q_forw );
  link_nodes( prev, lp );
  }
Пример #15
0
t_pos *read_file(char *file) {
  int size, x, y, ry, p, inctile;
  char line[MAX_LINE_SIZE];
  t_pos *ret = (t_pos *) malloc(sizeof(t_pos));
  t_hex *hex = &ret->hex;
  t_tiles *tiles = &ret->tiles;
  t_done *done = &ret->done;
  FILE *input;

  tiles_init(tiles);
  
  
  input = fopen(file, "rb");
  if (input == NULL) {
    free(ret);
    return NULL;
  }

  fgets(line, MAX_LINE_SIZE, input);
  sscanf(line, "%d", &size);
  hex_init(hex, size);
  done_init(done, hex->count);

  for (y = 0; y < size; ++y) {
    if (fgets(line, MAX_LINE_SIZE, input) == NULL) {
      printf("ERROR READING LINE %d!\n", y);
      free(ret);
      return NULL;
    }
    p = size - 1 - y;
    for (x = 0; x < size + y; ++x) {
      char *tile = line + p;
      p += 2;
      inctile = 0;
      if (tile[1] == '.') {
        inctile = 7;
      } else {
        inctile = tile[1] - '0';
      }
      if (tile[0] == '+') {
        printf("Adding locked tile: %d at pos %d, %d, id=%d\n",
               inctile, x, y, get_by_pos(hex, make_point(x, y))->id);
        add_done(done, get_by_pos(hex, make_point(x, y))->id, inctile);
      } else {
        (*tiles)[inctile] += 1;
      }
    }
  }
  for (y = 1; y < size; ++y) {
    ry = size - 1 + y;
    if (fgets(line, MAX_LINE_SIZE, input) == NULL) {
      printf("ERROR READING LINE %d!\n", ry);
      free(ret);
      return NULL;
    }
    p = y;
    for (x = y; x < 2 * size - 1; ++x) {
      char *tile = line + p;
      p += 2;
      inctile = 0;
      if (tile[1] == '.') {
        inctile = 7;
      } else {
        inctile = tile[1] - '0';
      }
      if (tile[0] == '+') {
        printf("Adding locked tile: %d at pos %d, %d, id=%d\n",
               inctile, x, ry, get_by_pos(hex, make_point(x, ry))->id);
        add_done(done, get_by_pos(hex, make_point(x, ry))->id, inctile);
      } else {
        (*tiles)[inctile] += 1;
      }
    }
  }
  fclose(input);

  pos_init(ret);
  link_nodes(hex);
  return ret;
}