Example #1
0
  void test_process_mark_stack() {
    immix::Block& block = gc->get_block();
    immix::SingleBlockAllocator alloc(block);
    memory::Address addr = alloc.allocate(sizeof(SimpleObject));
    memory::Address addr2 = alloc.allocate(sizeof(SimpleObject));

    SimpleObject* obj = addr.as<SimpleObject>();
    SimpleObject* sub = addr2.as<SimpleObject>();

    obj->marked = false;
    obj->sub = sub;
    obj->body_checked = false;

    sub->marked = false;
    sub->sub = 0;
    sub->body_checked = false;

    gc->mark_address(addr, alloc);
    TS_ASSERT_EQUALS(obj->marked, true);

    gc->process_mark_stack(alloc);
    TS_ASSERT_EQUALS(obj->body_checked, true);
    TS_ASSERT_EQUALS(sub->marked, true);
    TS_ASSERT_EQUALS(sub->body_checked, true);
  }
Example #2
0
  void test_sweep_blocks_frees_empty_blocks() {
    immix::Block& block = gc->get_block();

    gc->sweep_blocks();
    immix::Block& block2 = gc->get_block();
    TS_ASSERT_EQUALS(&block, &block2);
  }
Example #3
0
bool GCM_API Distance::matchCache(GC<Geocache> cache) {
	if (this->mUseCacheDistance) {
		return cache->getDistance().distance < this->distance;
	} else {
		return cache->calcDistance(this->latitudeE6, this->longitudeE6) < this->distance;
	}
}
Example #4
0
 void ObjectVectorObject::grow(uint32 newCapacity, bool exact)
 {
     if (newCapacity > m_capacity)
     {
         if(!exact)
             newCapacity = newCapacity + (newCapacity >>2);
         //newCapacity = ((newCapacity+kGrowthIncr)/kGrowthIncr)*kGrowthIncr;
         GC* gc = GC::GetGC(this);
         Atom* newArray = (Atom*) gc->Calloc(newCapacity, sizeof(Atom), GC::kContainsPointers);
         nullAtomRange(newArray, newCapacity);
         Atom* oldAtoms = m_array;
         if (!newArray)
         {
             toplevel()->throwError(kOutOfMemoryError);
         }
         if (m_array)
         {
             VMPI_memcpy(newArray, m_array, m_length * sizeof(Atom));
             nullAtomRange(oldAtoms, m_length);
             gc->Free(oldAtoms);
         }
         m_array = newArray;
         m_capacity = newCapacity;
     }
 }
Example #5
0
File: calc.cpp Project: hsk/docs
static Val* model() {
  AutoPool autopool;
  Val* val = (Val*)pool_ret(pool(gc.oarray(3)));
  val->result = pool(gc.str("Calc"))->chars;
  val->b = eval(ebin(EMul, ebin(EAdd,eint(1),eint(2)), eint(5)))->longv;
  val->c = eval(ebin(EDiv, ebin(EMul,eint(10),eint(20)), eint(5)))->longv;
  return val;
}
Example #6
0
  void test_mark_address_updates_block() {
    immix::Block& block = gc->get_block();
    immix::SingleBlockAllocator alloc(block);
    memory::Address addr = alloc.allocate(24);

    TS_ASSERT(block.is_line_free(1));
    gc->mark_address(addr, alloc);
    TS_ASSERT(!block.is_line_free(1));
  }
Example #7
0
void StaticLine::Paint(GC &gc, const crect &paintRect)
{
	crect rect = ClientRect();
	gc.SetFillColor(UiGetColor(uiBackground, 0,0, 0xFFFFFF)/*GetColor(0)*/);
	gc.FillRect(rect); //CCC
	gc.SetTextColor(UiGetColor(uiColor, 0,0, 0)/*GetColor(IsEnabled() ? IC_TEXT : IC_GRAY_TEXT)*/); //CCC
	gc.Set(GetFont());
	DrawStaticText(gc,0,0,text.ptr());
}
Example #8
0
  void test_get_block_returns_recyclable_blocks() {
    immix::Block& block  = gc->get_block();
    block.set_status(immix::cRecyclable);

    gc->sweep_blocks();

    immix::Block& block2 = gc->get_block();

    TS_ASSERT_EQUALS(&block2, &block);
  }
Example #9
0
File: calc.cpp Project: hsk/docs
static Object* eval(Object* e) {
	switch(e->longs[0]) {
	case EInt: return pool(gc.longv(e->longs[1]));
	case EAdd: return pool(gc.longv(eval(e->field[1])->longv + eval(e->field[2])->longv));
	case ESub: return pool(gc.longv(eval(e->field[1])->longv - eval(e->field[2])->longv));
	case EMul: return pool(gc.longv(eval(e->field[1])->longv * eval(e->field[2])->longv));
	case EDiv: return pool(gc.longv(eval(e->field[1])->longv / eval(e->field[2])->longv));
	default: return pool(gc.longv(1));
	}
}
Example #10
0
	void StaticLabel::Paint(GC& gc, const crect& paintRect)
	{
		crect rect = ClientRect();
		gc.SetFillColor(UiGetColor(uiBackground, uiClassStaticLabel, 0, 0xFFFFFF)/*GetColor(0)*/);
		gc.FillRect(rect); 
		gc.Set(GetFont());
		text.DrawItem(gc, 0, 0, 
			UiGetColor(uiColor, uiClassStaticLabel, 0, 0), 
			UiGetColor(uiHotkeyColor, uiClassStaticLabel, 0, 0));
	}
	static void DrawCE( GC& gc, int x, int y, bool isSet )
	{
		gc.SetLine( CBC_BOXFRAME );
		gc.SetFillColor( CBC_BOX_BG );
		gc.Ellipce( crect( x, y, x + 13, y + 13 ) );

		if ( isSet )
		{
			DrawPixelList( gc, rbPix, x + 4, y + 4, CBC_CHECK );
		}
	}
Example #12
0
  void test_mark_address_ignores_already_marked_objects() {
    immix::Block& block = gc->get_block();
    immix::SingleBlockAllocator alloc(block);
    memory::Address addr = alloc.allocate(24);

    addr.as<SimpleObject>()->marked = true;

    TS_ASSERT(block.is_line_free(1));
    gc->mark_address(addr, alloc);
    TS_ASSERT(block.is_line_free(1));
  }
Example #13
0
  void test_BlockAllocator_reset_updates_block_stats() {
    immix::Block& block = gc->get_block();

    block.mark_line(1);
    block.mark_line(3);

    TS_ASSERT_EQUALS(block.lines_used(), 1);
    immix::BlockAllocator& ba = gc->block_allocator();
    ba.reset();

    TS_ASSERT_EQUALS(block.lines_used(), 3);
  }
Example #14
0
	void PopupMenu::Paint( GC& gc, const crect& paintRect )
	{
		crect rect = ClientRect();
		gc.SetFillColor( UiGetColor( uiBackground, 0, 0, 0xFFFFFF ) );
		gc.FillRect( rect );
		DrawBorder( gc, rect, UiGetColor( uiFrameColor, 0, 0, 0 ) );

		for ( int i = 0; i < list.count(); i++ )
		{
			DrawItem( gc, i );
		}
	}
Example #15
0
void DrawStaticText(GC &gc, int x, int y, const unicode_t *s, cfont *font, bool transparent)
{
	if (font) gc.Set(font);
	while (*s) {
		const unicode_t *t = unicode_strchr(s,'\n');
		int len = (t ? t-s : unicode_strlen(s));
		gc.TextOutF(x,y,s,len);
		cpoint c = gc.GetTextExtents(s,len);
		s +=len;
		if (t) s++;
		if (*s == '\r') s++;
		y += c.y;
	}
}
Example #16
0
	void VListWin::Paint( GC& gc, const crect& paintRect )
	{
		crect rect = ClientRect();

		switch ( borderType )
		{
			case SINGLE_BORDER:
				DrawBorder( gc, rect, InFocus() ? 0x00C000 : borderColor );
				break;

			case BORDER_3D:
				Draw3DButtonW2( gc, rect, bgColor, false );

			default:
				;
		}

		if ( !scrollRect.IsEmpty() )
		{
			gc.SetFillColor( 0xD0D0D0 );
			gc.FillRect( scrollRect ); //CCC
		}

		if ( itemHeight > 0 )
		{
			int n = ( rect.Height() + ( itemHeight - 1 ) ) / itemHeight;
			crect r = this->listRect;
			int bottom = r.bottom;
			r.bottom = r.top + itemHeight;

			for ( int i = 0; i < n; i++ )
			{
				gc.SetClipRgn( &r );
				crect r1( r );
				r1.left -= xOffset;
				this->DrawItem( gc, i + first, r1 );
				r.top += itemHeight;
				r.bottom += itemHeight;

				if ( r.bottom > bottom ) { r.bottom = bottom; }
			}
		}
		else
		{
			//на всякий случай
			rect.Dec();
			gc.SetFillColor( bgColor );
			gc.FillRect( rect );
		}
	}
Example #17
0
  void test_sweep_blocks_sorts_blocks() {
    immix::Block& block  = gc->get_block();
    immix::Block& block2 = gc->get_block();
    immix::Block& block3 = gc->get_block();

    block.set_status(immix::cUnavailable);
    block2.set_status(immix::cRecyclable);
    gc->evacuate_block(block3);
    TS_ASSERT_EQUALS(block3.status(), immix::cEvacuate);

    gc->sweep_blocks();

    TS_ASSERT_EQUALS(block3.status(), immix::cFree);
  }
Example #18
0
File: syn_utils.c Project: vigna/ne
void gc_collect(GC **gc)
{
	GC *g = *gc;
	while (g) {
		GC *next = g->next;
		if (*g->var) {
			g->rm(*g->var);
			*g->var = 0;
		}
		fr_single(&gc_free_list,g);
		g = next;
	}
	*gc = 0;
}
Example #19
0
File: Sampler.cpp Project: bsdf/trx
 void AttachSampler(avmplus::Sampler* sampler)
 {
     GCHeap* heap = GCHeap::GetGCHeap();     // May be NULL during OOM shutdown
     if (heap)
     {
         EnterFrame* ef = heap->GetEnterFrame();
         if (ef)
         {
             GC* gc = ef->GetActiveGC();
             if (gc)
                 gc->SetAttachedSampler(sampler);
         }
     }
 }
	void ScrollBar::Paint( GC& gc, const crect& paintRect )
	{
		crect cr = ClientRect();
		unsigned bgColor = UiGetColor( uiBackground, 0, 0, 0xD8E9EC );/*GetColor(IC_SCROLL_BG)*/;
		unsigned btnColor = UiGetColor( uiButtonColor, 0, 0, 0xD8E9EC ); //GetColor(IC_SCROLL_BUTTON);
		gc.SetFillColor( bgColor );
		gc.FillRect( cr );
		DrawBorder( gc, cr, UiGetColor( uiColor, 0, 0, 0xD8E9EC )/*GetColor(IC_SCROLL_BORDER)*/ );

		if ( !b1Rect.IsEmpty() ) { SBCDrawButton( gc, b1Rect, vertical ? 4 : 1, btnColor, b1Pressed ); }

		if ( !b2Rect.IsEmpty() ) { SBCDrawButton( gc, b2Rect, vertical ? 5 : 2, btnColor, b2Pressed ); }

		if ( !b3Rect.IsEmpty() ) { SBCDrawButton( gc, b3Rect, vertical ? 6 : 3, btnColor, false ); }
	}
Example #21
0
File: Sampler.cpp Project: bsdf/trx
 avmplus::Sampler* GetSampler()
 {
     GCHeap* heap = GCHeap::GetGCHeap();     // May be NULL during OOM shutdown
     if (heap)
     {
         EnterFrame* ef = heap->GetEnterFrame();
         if (ef)
         {
             GC* gc = ef->GetActiveGC();
             if (gc)
                 return (avmplus::Sampler*)gc->GetAttachedSampler();
         }
     }
     return NULL;
 }
Example #22
0
File: calc.cpp Project: hsk/docs
inline Object* pool_ret(Object* a) {
  for (list<Frame*>::iterator frame = gc.frame_list.begin(); frame != gc.frame_list.end();) {
    frame++;
    if(frame != gc.frame_list.end()) return gc.add_pool(*frame, a);
  }
  return a;
}
Example #23
0
 void test_get_block() {
   immix::Block& block = gc->get_block();
   TS_ASSERT_EQUALS(block.size(), immix::cBlockSize);
   TS_ASSERT(block.address() != 0);
   TS_ASSERT_EQUALS(block.status(), immix::cFree);
   TS_ASSERT_EQUALS(block.lines_used(), 1);
 }
Example #24
0
 void test_BlockAllocator_get_free_block() {
   immix::BlockAllocator& ba = gc->block_allocator();
   ba.add_chunk();
   ba.current_chunk().get_block(0).set_status(immix::cRecyclable);
   immix::Block& block = ba.get_free_block();
   TS_ASSERT_EQUALS(block.status(), immix::cFree);
 }
Example #25
0
File: calc.cpp Project: hsk/docs
static Object* ebin(long tag, Object* e1, Object* e2) {
  Object* e = pool(gc.record(3,BIT(1) | BIT(2)));
  e->longs[0] = tag;
  e->field[1] = e1;
  e->field[2] = e2;
  return e;
}
Example #26
0
  void test_mark_address_calls_describer() {
    immix::Block& block = gc->get_block();
    immix::SingleBlockAllocator alloc(block);
    memory::Address addr = alloc.allocate(sizeof(SimpleObject));

    SimpleObject* obj = addr.as<SimpleObject>();
    memory::Address addr2 = alloc.allocate(sizeof(SimpleObject));
    obj->sub = addr2.as<SimpleObject>();

    obj->marked = false;

    gc->mark_address(addr, alloc);

    TS_ASSERT_EQUALS(obj->marked, true);
    TS_ASSERT_EQUALS(gc->mark_stack().size(), 1U);
    TS_ASSERT_EQUALS(gc->mark_stack()[0], addr);
  }
Example #27
0
cpoint StaticTextSize(GC &gc, const unicode_t *s, cfont *font)
{
	cpoint p(0,0);
	if (font) gc.Set(font);
	while (*s) {
		const unicode_t *t = unicode_strchr(s,'\n');
		int len = (t ? t-s : unicode_strlen(s));

		cpoint c = gc.GetTextExtents(s,len); 
		s +=len;
		if (t) s++;
		if (*s == '\r') s++;
		p.y += c.y;
		if (p.x<c.x) p.x = c.x;
	}
	return p;
}
Example #28
0
void MenuBar::DrawItem(GC &gc, int n)
{
	if (n<0 || n>=list.count()) return;
	
	UiCondList ucl;
	if (n == select && InFocus()) ucl.Set(uiCurrentItem, true);
		
	int color_text = UiGetColor(uiColor, uiItem, &ucl, 0x0);
	int color_bg = UiGetColor(uiBackground, uiItem, &ucl, 0xFFFFFF);

	gc.Set(GetFont());
	crect itemRect = ItemRect(n);

	gc.SetFillColor(color_bg);
	if (n == select && InFocus()) gc.FillRect(itemRect);	

	if (n == select) {
		DrawBorder(gc, itemRect, UiGetColor(uiCurrentItemFrame, uiItem, &ucl, 0xFFFFFF));
	}

	gc.SetTextColor( color_text );
	
	const unicode_t *text = list[n].text.ptr();
	cpoint tsize = gc.GetTextExtents(text);
	int x = itemRect.left + (itemRect.Width()-tsize.x)/2;
	int y = itemRect.top + (itemRect.Height()-tsize.y)/2;
	
#ifdef _WIN32	
	gc.TextOut(x,y,text);
#else	
	gc.TextOutF(x,y,text);
#endif	
}
	void Draw3DButtonW1( GC& gc, crect r, unsigned bg, bool up )
	{
		static unsigned hp1, lp1;
		static unsigned lastBg = 0;
		static bool initialized = false;

		if ( !initialized || lastBg != bg )
		{
			hp1 = ColorTone( bg, 200 );
			lp1 = ColorTone( bg, -150 );
			lastBg = bg;
			initialized = true;
		}

		unsigned php1, plp1;

		if ( up )
		{
			php1 = hp1;
			plp1 = lp1;
		}
		else
		{
			php1 = lp1;
			plp1 = hp1;
		}

		gc.SetLine( plp1 );
		gc.MoveTo( r.right - 1, r.top );
		gc.LineTo( r.right - 1, r.bottom - 1 );
		gc.LineTo( r.left, r.bottom - 1 );
		gc.SetLine( php1 );
		gc.LineTo( r.left, r.top );
		gc.LineTo( r.right - 1, r.top );
	}
Example #30
0
  void test_Block_update_stats_finds_empty_blocks() {
    immix::Block& block = gc->get_block();

    block.set_status(immix::cRecyclable);
    block.update_stats();
    TS_ASSERT_EQUALS(block.status(), immix::cFree);
    TS_ASSERT_EQUALS(block.holes(), 1);
    TS_ASSERT_EQUALS(block.lines_used(), 1);
  }