/**********************************************************
 * mm_malloc
 * Allocate a block of size bytes.
 * The type of search is determined by find_fit
 * The decision of splitting the block, or not is determined
 *   in place(..)
 * If no block satisfies the request, the heap is extended
 **********************************************************/
void *mm_malloc(size_t size)
{
	//mm_check();
	//print_seg(0);
//	printf("IN MALLOC\n");
    size_t asize; /* adjusted block size */
    size_t extendsize; /* amount to extend heap if no fit */
    char * bp;

    /* Ignore spurious requests */
    if (size == 0)
        return NULL;

    /* Adjust block size to include overhead and alignment reqs. */
    if (size <= DSIZE)
        asize = 2 * DSIZE;
    else
        asize = DSIZE * ((size + (DSIZE) + (DSIZE-1))/ DSIZE);

    /* Search the free list for a fit */
    if ((bp = find_segregated_best_fit(asize)) != NULL) {

    	//printf("free size found, bp is %p\n",bp);
    	remove_free_block(bp);
        place(bp, asize);
        return bp;
    };

    /* No fit found. Get more memory and place the block */
    extendsize = MAX(asize, CHUNKSIZE);
    if ((bp = extend_heap(extendsize/WSIZE)) == NULL)
    {
        return NULL;
    }
    place(bp, asize);
    return bp;

}

void
dosub(void)
{
	Rune *lp, *sp, *rp;
	int c, n;

	lp = linebuf;
	sp = genbuf;
	rp = rhsbuf;
	while(lp < loc1)
		*sp++ = *lp++;
	while(c = *rp++) {
		if(c == '&'){
			sp = place(sp, loc1, loc2);
			continue;
		}
		if(c == ESCFLG && (c = *rp++) >= '1' && c < MAXSUB+'0') {
			n = c-'0';
			if(subexp[n].s.rsp && subexp[n].e.rep) {
				sp = place(sp, subexp[n].s.rsp, subexp[n].e.rep);
				continue;
			}
			error(Q);
		}
		*sp++ = c;
		if(sp >= &genbuf[LBSIZE])
			error(Q);
	}
	lp = loc2;
	loc2 = sp - genbuf + linebuf;
	while(*sp++ = *lp++)
		if(sp >= &genbuf[LBSIZE])
			error(Q);
	lp = linebuf;
	sp = genbuf;
	while(*lp++ = *sp++)
		;
}

/* 
 * mm_malloc - Allocate a block by incrementing the brk pointer.
 *     Always allocate a block whose size is a multiple of the alignment.
 */
void *mm_malloc(size_t size)
{
    /*int newsize = ALIGN(size + SIZE_T_SIZE);
    void *p = mem_sbrk(newsize);
    if (p == (void *)-1)
	return NULL;
    else {
        *(size_t *)p = size;
        return (void *)((char *)p + SIZE_T_SIZE);
    } */

	size_t asize;
	size_t extendsize;
	char *bp;

	//ignore spurious requests
	if(size == 0)
		return NULL;
	
	//adjust block size to include overhead and alignment reqs
	if(size <= DSIZE)
		asize = 2*DSIZE;
	else
		asize = DSIZE * ((size + (DSIZE) + (DSIZE-1)) / DSIZE);

	//search the free list for a fit
	if((bp = find_fit(asize)) != NULL) {
		place(bp, asize);
		return bp;
	}

	//no fit found, get more memory and place the block
	extendsize = MAX(asize, CHUNKSIZE);
	if((bp = extend_heap(extendsize/WSIZE)) == NULL)
		return NULL;
	place(bp, asize);
	return bp;
}

 void place(int *arr, int n, int k, int &count){
     if(k == n){
         ++count;
         return;
     }
     else{
         for(int i = 0; i != n; ++i){
             if(check(arr, n, k, i)){
                 arr[k] = i;
                 place(arr, n, k+1, count);
             }
         }
     }
 }

void scroll_label::set_label(const t_string& lbl)
{
	// Inherit.
	styled_widget::set_label(lbl);

	if(label* widget = get_internal_label()) {
		widget->set_label(lbl);

		bool resize_needed = !content_resize_request();
		if(resize_needed && get_size() != point()) {
			place(get_origin(), get_size());
		}
	}
}

		optional& operator=( const optional& that ) {
			if ( std::addressof( that ) == this )
				return *this;
			if ( present && that.present )
				**this = *that;
			else if ( present )
				destroy( );
			else if ( that.present )
				place( *that );
			else
				present = false;

			return *this;
		}

		optional& operator=( optional&& that ) {
			if ( std::addressof( that ) == this )
				return *this;
			if ( present && that.present )
				value( ) = std::move( that.value( ) );
			else if ( present )
				destroy( );
			else if ( that.present )
				place( std::move( *that ) );
			else
				present = false;

			return *this;
		}

ConnectionDialog::ConnectionDialog(const std::string &text,
                                   const State cancelState):
    Window(""),
    gcn::ActionListener(),
    mCancelState(cancelState)
{
    setTitleBarHeight(0);
    setMovable(false);
    setMinWidth(0);

    ProgressIndicator *const progressIndicator = new ProgressIndicator;
    Label *const label = new Label(this, text);
    Button *const cancelButton = new Button(
        // TRANSLATORS: connection dialog button
        this, _("Cancel"), "cancelButton", this);

    place(0, 0, progressIndicator);
    place(0, 1, label);
    place(0, 2, cancelButton).setHAlign(LayoutCell::CENTER);
    reflowLayout();

    center();
}

 int queen(int t)   
 {   
   int i;
     if(t>n && n>0) //当放置的皇后超过n时，可行解个数加1，此时n必须大于0   
       sum++;   
     else  
       for( i=1;i<=n;i++)   
       {   
           x[t] = i; //标明第t个皇后放在第i列   
           if(place(t)) //如果可以放在某一位置，则继续放下一皇后   
             queen(t+1);    
       }   
     return sum;   
 }   

		optional& operator=(const optional& that) {
			if (std::addressof(that) == this)
				return *this;
			if (valid() && that.valid())
				**this = *that;
			else if (valid())
				unchecked_destroy();
			else if (that.valid())
				place(*that);
			else
				present = false;

			return *this;
		}

int solve(int mask, int r, int c) {
  if( r == n ) return 1;

  int nr = (c == n-1 ? r+1 : r), nc = (c == n-1 ? 0 : c+1);

  if( !empty[r][c] ) {
    if( ok(r, c, a[r][c]) ) {
      place(r, c, a[r][c]);
      return solve(mask | (1<<a[r][c]), nr, nc);
    }
    return 0;
  }

  for( int i = square_of_n; i > 0; --i )
    if( !((1<<i) & mask) && ok(r, c, i) ) {
      place(r, c, i);
      int found = solve(mask | (1<<i), nr, nc);
      if( found ) return 1;
      else remove(r, c, i);
    }

  return 0;
}

void    Amt::DiagLImpl::applyAttrs(){
	crtc::ItemNode::applyAttrs();
        visible( 1 );
	gtk_widget_show_all(_in_widget);
	if( uart = dynamic_cast<riku::Iuart*>(riku::stdRegister::getRegister().getUart()) ){
	    apply = true;
	    if ((_in_mod_id != "") && !_in_place.length() )
		place((std::string("Место: ")+std::string(uart->get_mPlace(_in_mod_id)) ).c_str() );
	    registerForStep__( );
	}
	else	
	    std::cout<<"\t dynamic_cast crtc::DiagLImpl->Amt::UartImpl ERROR\n";

}

//place a queen in a col of the row
void place(int *pos, int row)
{
	int j;

	for (j = 0; j < N; j++) {
		if (can_place(pos, row, j)) {
			pos[row] = j;
			if (row == N-1)
				output(pos);
			else
				place(pos, row+1);
		}
	}
}

std::string CodeLocation::str () const
{
  char line [50];
  sprintf (line, "%d", m_line);
  std::string place (m_file);
  place += ":";
  place += line;
  if ( strlen(m_function) ) // skip if compiler does not set function
  {
    place += ":";
    place += m_function;
  }
  return place;
}

void new_player_t::open()
{
	init(gengine);
	place(wmain->x(), wmain->y(), wmain->width(), wmain->height());
	font(B_NORMAL_FONT);
	foreground(wmain->map_rgb(255, 255, 255));
	background(wmain->map_rgb(0, 0, 0));
	memset(name, 0, sizeof(name));
	name[0] = 'A';
	currentIndex = 0;
	editing = 1;
	build_all();
	SDL_EnableUNICODE(1);
}

void Position::applyMove(Square sq)
{
    place(sq, currentPlayer());

    for (int d = 0; d < TOT_DIR; ++d) {
        if (isValidMove(sq, DIR[d]))
            reverse(sq, DIR[d]);
    }

    ++count[currentPlayer()];
    nullMoveCount = 0;

    changePlayer();
}

void
dosub(uchar *rhsbuf)
{
	uchar *lp, *sp, *rp;
	int c;

	lp = linebuf;
	sp = genbuf;
	rp = rhsbuf;
	while (lp < loc1)
		*sp++ = *lp++;
	while(c = *rp++) {
		if (c == '\\') {
			c = *rp++;
			if (c >= '1' && c < NBRA+'1') {
				sp = place(sp, braslist[c-'1'], braelist[c-'1']);
				continue;
			}
		} else if(c == '&') {
				sp = place(sp, loc1, loc2);
				continue;
		}
		*sp++ = c;
		if (sp >= &genbuf[LBSIZE])
			fprintf(stderr, "sed: Output line too long.\n");
	}
	lp = loc2;
	loc2 = sp - genbuf + linebuf;
	while (*sp++ = *lp++)
		if (sp >= &genbuf[LBSIZE]) {
			fprintf(stderr, "sed: Output line too long.\n");
		}
	lp = linebuf;
	sp = genbuf;
	while (*lp++ = *sp++);
	spend = lp-1;
}

/* 
 * mm_malloc - Allocate a block by incrementing the brk pointer.
 *     Always allocate a block whose size is a multiple of the alignment.
 */
void *mm_malloc(size_t size)
{
    size_t asize;
    /*asize = overrall size with overhead + alignment*/
    size_t extendsize;
    char *bp;
#ifdef DEBUG
    printf("[%d] malloc called with %d\n",++mCnt,size);
#endif

    if(size <= 0)
        return NULL;
    if(size <= WSIZE)
        printf("<WISZE\n");

    if(size <= DSIZE)
        asize = DSIZE + OVERHEAD;
    else
        asize = ALIGN(size + OVERHEAD);

    if((bp = find_fit(asize)) != NULL){
#ifdef DEBUG
        printf("find a slot at %d \n",bp-heap_listp);
#endif
        place(bp,asize);
        return bp;
    }
    //Exam_list(asize);
    extendsize = MAX(asize,C4K);

    if((bp = extend_heap(extendsize/WSIZE)) == NULL)
        return NULL;
    place(bp, asize);

    //Exam_list();
    return bp;
}

/*
 * malloc
 */
void *malloc (size_t size) {
    size_t asize;      /* Adjusted block size */
    size_t extendsize; /* Amount to extend heap if no fit */
    char *bp;      

    /* Re-initiate */
    if (first_block == 0){
        mm_init();
    }
    /* Ignore spurious requests */
    if (size == 0)
        return NULL;
    /* Adjust block size to include overhead and alignment*/
    asize = MAX(ALIGN(size + WSIZE), MINSIZE * WSIZE);

    assert(asize >= MINSIZE * WSIZE);

    /* Search the free list for a fit */
    if ((bp = find_fit(asize)) != NULL) {        
        place(bp, asize);                  
#ifdef DEBUG   
        mm_checkheap(1);        
#endif        
        return bp;
    }

    /* No fit found. Get more memory and place the block */
    extendsize = MAX(asize,CHUNKSIZE);                
    if (NULL == (bp = extend_heap(extendsize/WSIZE)))
            return NULL;

    place(bp, asize);                                 
#ifdef DEBUG        
    mm_checkheap(1);    
#endif    
    return bp;
}

/*
 * malloc: adjust the size to the minimum block size or a
 * multiple of alignment. Search the free list for a fit,
 * if not, extend the heap
 */
void *malloc (size_t size) {
    //checkheap(1);  // Let's make sure the heap is ok!
    size_t asize; // adjust size
    size_t extendsize;
    char *bp;

    if (size <= 0){
        return NULL;
    }

    // Adjust the size to at least the minimum blk size and 
    // a multiple of alignment 8
    if (size <= (DSIZE + WSIZE)){
        asize = 2 * DSIZE;
    }
    else{
        asize = DSIZE*((size + DSIZE + (DSIZE - 1)) / DSIZE);
    }

    // search the freelist for a fit 
    if ((bp = findFit(asize)) != NULL){
        place(bp, asize);
        return bp;
    }

    // If no fit, extend the heap
    if(asize>CHUNKSIZE)
        extendsize = asize;
    else
        extendsize = CHUNKSIZE;

    if ((bp = extendHeap(extendsize / WSIZE)) == NULL)
        return NULL;
    place(bp, asize);

    return bp;
}