MarkedBlock::FreeList MarkedBlock::specializedSweep()
{
ASSERT(blockState != Allocated && blockState != FreeListed);
ASSERT(destructorCallNeeded || sweepMode != SweepOnly);
// This produces a free list that is ordered in reverse through the block.
// This is fine, since the allocation code makes no assumptions about the
// order of the free list.
FreeCell* head = 0;
size_t count = 0;
for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell) {
if (blockState == Marked && m_marks.get(i))
continue;
JSCell* cell = reinterpret_cast_ptr<JSCell*>(&atoms()[i]);
if (blockState == Zapped && !cell->isZapped())
continue;
if (destructorCallNeeded && blockState != New)
callDestructor(cell);
if (sweepMode == SweepToFreeList) {
FreeCell* freeCell = reinterpret_cast<FreeCell*>(cell);
freeCell->next = head;
head = freeCell;
++count;
}
}
m_state = ((sweepMode == SweepToFreeList) ? FreeListed : Zapped);
return FreeList(head, count * cellSize());
}
MarkedBlock::FreeList MarkedBlock::specializedSweep()
{
ASSERT(blockState != Allocated && blockState != FreeListed);
ASSERT(!(dtorType == MarkedBlock::None && sweepMode == SweepOnly));
// This produces a free list that is ordered in reverse through the block.
// This is fine, since the allocation code makes no assumptions about the
// order of the free list.
FreeCell* head = 0;
size_t count = 0;
for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell) {
if (blockState == Marked && (m_marks.get(i) || (m_newlyAllocated && m_newlyAllocated->get(i))))
continue;
JSCell* cell = reinterpret_cast_ptr<JSCell*>(&atoms()[i]);
if (dtorType != MarkedBlock::None && blockState != New)
callDestructor(cell);
if (sweepMode == SweepToFreeList) {
FreeCell* freeCell = reinterpret_cast<FreeCell*>(cell);
freeCell->next = head;
head = freeCell;
++count;
}
}
// We only want to discard the newlyAllocated bits if we're creating a FreeList,
// otherwise we would lose information on what's currently alive.
if (sweepMode == SweepToFreeList && m_newlyAllocated)
m_newlyAllocated.clear();
m_state = ((sweepMode == SweepToFreeList) ? FreeListed : Marked);
return FreeList(head, count * cellSize());
}
void PMBullet::move()
{
QList<QGraphicsItem *> colliding_enemies=collidingItems();
for(size_t i=0, n=colliding_enemies.size();i<n;i++){
if((typeid(*(colliding_enemies[i]))==typeid(Enemy))||typeid(*(colliding_enemies[i]))==typeid(AttackableEnemy)){
if(typeid(*(colliding_enemies[i]))==typeid(Enemy)){
dynamic_cast<Enemy*>(colliding_enemies[i])->IsSlowedBy(SlowPower);
dynamic_cast<Enemy*>(colliding_enemies[i])->IsHitBy(AttackPower);
}
else if(typeid(*(colliding_enemies[i]))==typeid(AttackableEnemy)){
dynamic_cast<AttackableEnemy*>(colliding_enemies[i])->IsSlowedBy(SlowPower);
dynamic_cast<AttackableEnemy*>(colliding_enemies[i])->IsHitBy(AttackPower);
}
playSound("Hit"); //sound for hit
game->scene->removeItem(this);
QTimer::singleShot(3000,this,SLOT(callDestructor()));
return;
}
}
double theta = rotation(); //set theta
double dy = STEP_SIZE*qSin(qDegreesToRadians(theta));
double dx = STEP_SIZE*qCos(qDegreesToRadians(theta));
setPos(x()+dx,y()+dy);
}
void icetDestroyContext(IceTContext context)
{
IceTContext saved_current_context;
saved_current_context = icetGetContext();
if (context == saved_current_context) {
icetRaiseDebug("Destroying current context.");
saved_current_context = NULL;
}
/* Temporarily make the context to be destroyed current. */
icetSetContext(context);
/* Call destructors for other dependent units. */
callDestructor(ICET_RENDER_LAYER_DESTRUCTOR);
/* From here on out be careful. We are invalidating the context. */
context->magic_number = 0;
icetStateDestroy(context->state);
context->state = NULL;
context->communicator->Destroy(context->communicator);
/* The context is now completely destroyed and now null. Restore saved
context. */
icetSetContext(saved_current_context);
}
static EXPRESSION *createLambda(BOOLEAN noinline)
{
EXPRESSION *rv = NULL, **cur = &rv;
HASHREC *hr;
EXPRESSION *clsThs, *parentThs;
SYMBOL *cls = makeID(lambdas->enclosingFunc ? sc_auto : sc_localstatic, lambdas->cls->tp, NULL, AnonymousName());
SetLinkerNames(cls, lk_cdecl);
cls->allocate = TRUE;
if (lambdas->enclosingFunc)
{
insert(cls, localNameSpace->syms);
clsThs = varNode(en_auto, cls); // this ptr
}
else
{
insert(cls, globalNameSpace->syms); // well if we could put this as an auto in the init func that would be good but there is no way to do that here...
clsThs = varNode(en_label, cls); // this ptr
cls->label = nextLabel++;
insertInitSym(cls);
}
{
INITIALIZER *init = NULL;
EXPRESSION *exp = clsThs;
callDestructor(cls, NULL, &exp, NULL, TRUE, FALSE, FALSE);
initInsert(&init, cls->tp, exp, 0, TRUE);
if (cls->storage_class != sc_auto)
{
insertDynamicDestructor(cls, init);
}
else
{
cls->dest = init;
}
}
parentThs = varNode(en_auto, (SYMBOL *)basetype(lambdas->func->tp)->syms->table[0]->p); // this ptr
hr = lambdas->cls->tp->syms->table[0];
while (hr)
{
SYMBOL *sp = (SYMBOL *)hr->p;
EXPRESSION *en = NULL, *en1 = NULL;
if (!strcmp(sp->name, "$self"))
{
en1 = clsThs;
en = varNode(en_label, sp);
deref(&stdpointer, &en);
en = exprNode(en_assign, en, en1);
}
else if (!strcmp(sp->name, "$parent"))
{
en1 = parentThs; // get parent from function call
deref(&stdpointer, &en1);
en = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)) ;
deref(&stdpointer, &en);
en = exprNode(en_assign, en, en1);
}
else if (!strcmp(sp->name, "$this"))
{
if (!lambdas->next || !lambdas->captureThis)
{
en1 = parentThs; // get parent from function call
}
else
{
SYMBOL *parent = search("$parent", lambdas->cls->tp->syms);
en1 = varNode(en_auto, cls);
deref(&stdpointer, &en1);
en1 = exprNode(en_add, en1, intNode(en_c_i, parent->offset));
}
deref(&stdpointer, &en1);
en = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)) ;
deref(&stdpointer, &en);
en = exprNode(en_assign, en, en1);
}
else if (sp->lambdaMode)
{
LAMBDASP *lsp = (LAMBDASP *)search(sp->name, lambdas->captured);
if (lsp)
{
en1 = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset));
if (sp->lambdaMode == cmRef)
{
SYMBOL *capture = lsp->parent;
deref(&stdpointer, &en1);
if (capture->lambdaMode)
{
en = parentThs;
deref(&stdpointer, &en);
en = exprNode(en_add, en, intNode(en_c_i, capture->offset));
}
else // must be an sc_auto
{
en = varNode(en_auto, capture);
}
if (isref(capture->tp))
{
deref(&stdpointer, &en);
}
en = exprNode(en_assign, en1, en);
}
else // cmValue
{
SYMBOL *capture = lsp->parent;
TYPE *ctp = capture->tp;
if (capture->lambdaMode)
{
en = parentThs;
deref(&stdpointer, &en);
en = exprNode(en_add, en, intNode(en_c_i, capture->offset));
}
else // must be an sc_auto
{
en = varNode(en_auto, capture);
}
if (isref(ctp))
{
ctp = basetype(ctp)->btp;
deref(&stdpointer, &en);
}
if (isstructured(ctp))
{
FUNCTIONCALL *params = (FUNCTIONCALL *)Alloc(sizeof(FUNCTIONCALL));
params->arguments = (INITLIST *)Alloc(sizeof(INITLIST));
params->arguments->tp = ctp;
params->arguments->exp = en;
if (!callConstructor(&ctp, &en1, params, FALSE, NULL, TRUE, FALSE, TRUE, FALSE, FALSE))
errorsym(ERR_NO_APPROPRIATE_CONSTRUCTOR, lsp->sym);
en = en1;
}
else
{
deref(ctp, &en1);
deref(ctp, &en);
en = exprNode(en_assign, en1, en);
}
}
}
else
{
diag("createLambda: no capture var");
}
}
if (en)
{
*cur = exprNode(en_void, en, NULL);
cur = &(*cur)->right;
}
hr = hr->next;
}
*cur = clsThs; // this expression will be used in copy constructors, or discarded if unneeded
return rv;
}