void interpret(Interpreter interp, char* line){

//	for(int i=0; i<1000000000; ){i=hoge(i,1);}
/*	for(int i=0; i<1000000*100; i++){
		if(!pool) fill_pool();
		obj rr=pool;
		pool = cdr(pool);
		rr->refcount = 1;
		rr->type = INT;
		if(rr->type == tNull) continue;
		rr->refcount--;
		cdr(rr) = pool;
		pool = rr;
	}//*/
/*	for(int i=0; i<1000000*100; i++){
		obj rr=alloc();
		rr->type = INT;
		release(rr);	
	}//*/

/*
obj u=Int(1);
obj e=Int(10000000);
obj x=Int(0);
//while(vrInt(compare('<', x, e))){
while(vrInt(LT(x, e))){
	obj r = add(x, u);
	release(x);
	x=r;
}
//*/
	curr_interp = interp;
	env = nil;
	obj stat = parseString(&line);

	obj rr = nil;
//	int t = TickCount();
	if(stat) {
		rr = eval(stat);
		release(stat);
	}
//	myPrintf(" %f sec.", (TickCount()-t)/60.);
	if(rr){
		myPrintf(">> ");
		print(rr);
		release(rr);
		scroll();
	}
}

/* GNOME bugzilla bug 111500.  Expand a row and immediately scroll
 * to its first child.  Make sure that expansion happens in currently
 * invisible area.
 */
static void
test_bug111500 (ScrollFixture *fixture,
		gconstpointer  test_data)
{
	int i, len;
	GtkTreeStore *store;
	GtkTreeIter parent;
	GtkTreePath *path;

	g_test_bug ("111500");

	gtk_widget_show_all (fixture->window);

	/* Make sure all events have been processed and the window
	 * is visible.
	 */
	while (gtk_events_pending ())
		gtk_main_iteration ();

	/* Further prepare model */
	store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fixture->tree_view)));

	for (i = 0; i < 15; i++) {
		GtkTreeIter iter;

		gtk_tree_store_append (store, &iter, NULL);
		gtk_tree_store_set (store, &iter, 0, "Other node", -1);
	}

	len = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL);
	gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &parent,
				       NULL, len - 1);

	for (i = 0; i < 5; i++) {
		GtkTreeIter iter;

		gtk_tree_store_append (store, &iter, &parent);
		gtk_tree_store_set (store, &iter, 0, "Row", -1);
	}

	path = gtk_tree_path_new_from_indices (len - 1, -1);
	gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view),
				  path, FALSE);

	gtk_tree_path_down (path);

	scroll (fixture, path, FALSE, 0.5);
	gtk_tree_path_free (path);
}

void printk(const char *message, ...)
{
	char *vid = lark_console.vid;
	unsigned char attr = lark_console.attr;
	unsigned int row = lark_console.row;
	unsigned int col = lark_console.col;
	va_list args;
	char *buf = &logbuf[0];
	int i;

	va_start(args, message);
	i = vsprintf(logbuf, message, args);
	va_end(args);

	/* it's important to keep in mind that col is in bytes but for
	 * each character we have 2 bytes. One for the character, and
	 * one for its attributes
	 */	
	while(*buf != 0) {
		/* FIXME: add tab support */
		if(*buf == '\n') {
			row++;
			col = 0;
			*buf++;
		} else if(*buf == '\r') {
		       	col = 0;
			*buf++;
		} else {
			vid[row*LINE_SIZE + col] = *buf;
			*buf++;
			col++;
			vid[row*LINE_SIZE + col] = attr;
			col++;
		}

		if(col >= lark_console.width){
			row++;
			col = 0;
		}
		if(row >= lark_console.height){
			scroll();
			row--;
		}
                
	}
	
	lark_console.row = row;
	lark_console.col = col;
}

int main (void) {
    int x = 40, zufall, c = 0 , i;
    srand(79);

    initscr();

    keypad(stdscr, TRUE);
    noecho();
    scrollok(stdscr, TRUE);
    scroll(stdscr);
    
    while (c != QUIT) {
        scrl(1);
        
        for (i = 0; i < 5; ++i) {
            zufall = rand() % 79;
            mvaddch(20, zufall, '*');
            mvprintw(0, 0, "'q' druecken fuer Quit | "
                     "Taste fuer Start | "
                     "<- nach links -> nach rechts");
            mvprintw(1,0, "Position Raumschiff %d", x);
        }
        
        c = getch();
        halfdelay(3);
        
        switch (c) {
            case LEFT:
                if (x < 1)
                    x = 79;
                else
                    --x;
                break;
            case RIGHT:
                if (x > 79)
                    x = 1;
                else
                    ++x;
                break;
            default:
                break;
        }
        print_raumschiff(x);
    }

    endwin();
    
    return 0;
}

void
newline(void)
{
	nbacklines--;
	if(y >= yscrmax) {
		y = yscrmax;
		if(pagemode && olines >= yscrmax) {
			blocked = 1;
			return;
		}
		scroll(yscrmin+1, yscrmax+1, yscrmin, yscrmax);
	} else
		y++;
	olines++;
}

void LCDST7565::menuDown()
{
	buty++;
	bool atBottom = false;
	do {
		if ((_current_line < N_LINES-2) & (_current_line < _n_items-1)) _current_line++;
		else scroll(1); // We're at the bottom line, scroll down if possible
		if (_item_index < _n_items-1)
		{
			_item_index++;
		}
		else atBottom = true;
	} while( _menu_items[_item_index].type == MENU_ITEM_TYPE_LINE && ! atBottom);
	update();
}

void Camera::followCinematic(Character& character, float dt)
{
	const float camX = _view.getCenter().x;
	const float camY = _view.getCenter().y;

	//lerp : V(t) = A + (B-A) * t
	//Linear Interpolation from Camera's center to Character's center
	const sf::Vector2f pos = character.getPosition();
	int x, y;
	x = (int)( camX + (pos.x - camX) * _speed.x*dt );
	y = (int)( camY + (pos.y - camY) * _speed.y*dt );

	scroll(x, y, x, y);
	_view.setCenter(x, y);
}

void VGA_Text_Buffer::put(char c) {
  if (c == '\n') {
    col = -1; // The column get incremented at the end, need to counteract that
    ++row;
  } else if (c == '\t') {
    col = col - (col % tab_width) + tab_width - 1;
  } else {
    at(row,col) = make_entry(c);
  }
  if (++col >= cols) {
    ++row;
    col = 0;
  }
  if (row >= rows) scroll();
}

void moverowdown(void)
/* Moves down one row */
{
 displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
 if (currow < bottomrow)
  currow++;
 else if (bottomrow < (MAXROWS - 1))
 {
  scroll(UP, 1, LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
  toprow++;
  currow++;
  setbottomrow();
  displayrow(bottomrow, NOUPDATE);
 }
} /* moverowdown */

void ExampleView::dragExampleView(QMouseEvent* ev)
      {
      QPoint d = ev->pos() - _matrix.map(startMove).toPoint();
      int dx   = d.x();
      if (dx == 0)
            return;

      constraintCanvas(&dx);

      // Perform the actual scrolling
      _matrix.setMatrix(_matrix.m11(), _matrix.m12(), _matrix.m13(), _matrix.m21(),
         _matrix.m22(), _matrix.m23(), _matrix.dx()+dx, _matrix.dy(), _matrix.m33());
      imatrix = _matrix.inverted();
      scroll(dx, 0);
      }

bool WebPage::performDefaultBehaviorForKeyEvent(const WebKeyboardEvent& keyboardEvent)
{
    if (keyboardEvent.type() != WebEvent::KeyDown && keyboardEvent.type() != WebEvent::RawKeyDown)
        return false;

    switch (keyboardEvent.windowsVirtualKeyCode()) {
    case VK_LEFT:
        scroll(m_page.get(), ScrollLeft, ScrollByLine);
        break;
    case VK_RIGHT:
        scroll(m_page.get(), ScrollRight, ScrollByLine);
        break;
    case VK_UP:
        scroll(m_page.get(), ScrollUp, ScrollByLine);
        break;
    case VK_DOWN:
        scroll(m_page.get(), ScrollDown, ScrollByLine);
        break;
    case VK_HOME:
        logicalScroll(m_page.get(), ScrollBlockDirectionBackward, ScrollByDocument);
        break;
    case VK_END:
        logicalScroll(m_page.get(), ScrollBlockDirectionForward, ScrollByDocument);
        break;
    case VK_PRIOR:
        logicalScroll(m_page.get(), ScrollBlockDirectionBackward, ScrollByPage);
        break;
    case VK_NEXT:
        logicalScroll(m_page.get(), ScrollBlockDirectionForward, ScrollByPage);
        break;
    default:
        return false;
    }

    return true;
}

void BrowCtx::center_object( GlowArrayElem *object, double factor)
{
  double ll_x, ll_y, ur_x, ur_y;
  int new_offset_y;
  int y_pix;

  ((GlowNode *)object)->measure( &ll_x, &ll_y, &ur_x, &ur_y);
  new_offset_y = int(ll_y * mw.zoom_factor_y - factor * mw.window_height);
  if ( new_offset_y <= 0)
    y_pix = mw.offset_y;
  else
    y_pix = - (new_offset_y - mw.offset_y);
  scroll( 0, y_pix);
  change_scrollbar();
}

void CNOutBarCtrl::OnTimer(UINT nIDEvent) 
{
	if (nIDEvent == IDT_SCROLL) {
		if (HITOBJ(pressedHit) == HT_SCROLL)
			scroll(HITINDEX(pressedHit));

	} else if (nIDEvent == IDT_DBLCLK) {
		KillTimer(IDT_DBLCLK);
		if (listener && lastHit == MAKEHIT(HT_ITEM, clickedItem))
			listener->itemClicked(clickedItem);
		clickedItem = -1;

	} else
		CWnd::OnTimer(nIDEvent);
}

// Prints raw text
void kprint_raw(const char text[]) {
    int i;

    for(i = 0; text[i] != '\0'; i++) {
        if(column >= 80) {
            row++;
            column = 0;

            if(row > TERM_ROWS)
                scroll();
        }

        if(text[i] == '\n') {
            row++;
            column = 0;

            if(row > TERM_ROWS)
                scroll();
        } else {
            kprintc(text[i], 0x07, column, row);
            column++;
        }
    }
}

void cputc(char c)
{
    static unsigned short scan_x,x,y;
    LIN_ADDR v = (LIN_ADDR)(0xB8000 + active_page*(2*PAGE_SIZE));
    x = bios_x;
    y = bios_y;
    switch (c) {
	case '\t' : x += 8;		
    		    if (x >= 80) {
			x = 0;
			if (y == 24) scroll();
			else y++;
    		    } else {
			scan_x = 0;
			while ((scan_x+8) < x) scan_x += 8;
			x = scan_x;
		    }
		    break;
	case '\n' : x = 0;
		    if (y == 24) scroll();
		    else y++;
		    break;
	case '\b' : x--;
		    lmempokeb((LIN_ADDR)(v + 2*(x + y*80)),' ');
		    x++;
		    break;
	default   : lmempokeb((LIN_ADDR)(v + 2*(x + y*80)),c);
		    x++;
    		    if (x > 80) {
			x = 0;
			if (y == 24) scroll();
			else y++;
    		    }
    }
    place(x,y);
}

void print_string(const unsigned char *str)
{
  unsigned char c;

  if (console_needs_init)
    init_console();

  while((c = *str++))
    switch(c)
      {
      case '\n':
	cursor_x = 0;
	cursor_y++;
	if(cursor_y == size_y)
	  {
	    scroll();
	    cursor_y = size_y - 1;
	  }
	break;

      default:
	print_char(cursor_x, cursor_y, c);
	cursor_x++;
	if(cursor_x == size_x)
	  {
	    cursor_x = 0;
	    cursor_y++;
	    if(cursor_y == size_y)
	      {
		scroll();
		cursor_y = size_y - 1;
	      }
	  }
	break;
      }
}

void showfont() {

    puts32("Text fontmap in use: ");
    uint16_t c = 0;
 
    while (c < 0x100) {
        video32[curpos32] = (VGA_ATTRIBUTE<<8) | c++;
	setcurpos32(curpos32+1);

        if (curpos32 >= (80 * VGA_LINES)) {
            scroll(1);
	}
    }
    putchar32('\n');
}

// display a char, handle special chars '\n','\r','\b'
int putc(char c)  
{
  int pos, w, offset;

  if (c=='\n'){
    row++;
    if (row>=25){
      row = 24;
      scroll();
    }
    pos = 2*(row*80 + column);
    offset = (org + pos) & vid_mask;
    set_VDC(CURSOR, offset >> 1);
    return; 
  }

void mputc( short n, char c )
{
	if (!OPEN) return;

//	if (keyd_pressed[KEY_BACKSP]) 
//		mono_int_3();

	switch (c)
	{
	case 8:
		if (CCOL > 0) CCOL--;
		break;
	case 9:
		CHAR( CROW, CCOL ) = ' ';
		ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
		XCHAR( CROW, CCOL ) = ' ';
		CCOL++;
		while (CCOL % 4) {
			CHAR( CROW, CCOL ) = ' ';
			ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
			XCHAR( CROW, CCOL ) = ' ';
			CCOL++;
		}
		break;
	case 10:
	case 13:
		CCOL = 0;
		CROW++;
		break;
	default:
		CHAR( CROW, CCOL ) = c;
		ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
		XCHAR( CROW, CCOL ) = c;
		CCOL++;
	}

	if ( CCOL >= WIDTH )    {
		CCOL = 0;
		CROW++;
	}
	if ( CROW >= HEIGHT )   {
		CROW--;
		scroll(n);
	}

	msetcursor( ROW+CROW, COL+CCOL );

}

void LineInput(char *buf, int len)
{
	int pos=0;
	int ch;
	while(1)
	{
		wrefresh(Bottom);
		ch=wgetch(Bottom);
		switch(ch)
		{
			case 10:;
			case 13:;
				buf[pos]=0;
				scroll(Bottom);
				wmove(Bottom, 11, 0);
				OutputPos = 0;
				return;
			case 8:;
			case 127:;
				if(pos>0)
				{
					int y,x;
					getyx(Bottom,y,x);
					x--;
					if(x==-1)
					{
						x=79;
						y--;
					}
					mvwaddch(Bottom,y,x,' ');
					wmove(Bottom,y,x);
					wrefresh(Bottom);
					pos--;
				}
				break;
			default:
				if(pos >= len)
					break;
				if(ch>=' '&&ch<=126)
				{
					buf[pos++]=ch;
					waddch(Bottom,(char)ch);
					wrefresh(Bottom);
				}
				break;
		}
	}
}