C++ Mark函数代码示例

void scContUnit::Iter( SubstituteFunc	func,
					   long				startLocation,
					   long&			limitOffset )
{
	UCS2			chBuf[64];
	UCS2*			chP;
	CharRecordP		startChRec;
	scSpecRecord*	specRec;
	long			startOffset,
					endOffset,
					wordLen;
	
	LockMem( startChRec, specRec );
	
	startOffset = startLocation;
	endOffset 	= startOffset;
	
	for ( ; endOffset < limitOffset; ) {
		startOffset = TXTStartSelectableWord( startChRec, endOffset );
		endOffset 	= TXTEndSelectableWord( startChRec, endOffset );
		wordLen = endOffset - startOffset;
		
		if ( wordLen > 1 ) {
			BuildTestWord( chBuf, startChRec + startOffset, wordLen );
			status stat = (*func)( &chP, chBuf, NULL );
			
			if ( stat == scSuccess || stat == scUserAbort ) {
				if ( !ReplaceWord( startChRec, specRec, startOffset, endOffset,
								   limitOffset, chBuf, chP ) ) {
						UnlockMem( );
						return;
				}
				
				fCharArray.RepairText( fSpecRun, startOffset, endOffset );
				Mark( scREBREAK );
				
				if ( stat == scUserAbort )
					goto exit;
			}
		}
		endOffset = FindNextSpellingWord( startChRec, endOffset, limitOffset );
	}

exit:
	UnlockMem( );
}

void GarbageCollector::PerformGC(RunTimeStack &s)
	{
	// Perform mark-and-sweep garbage collection.  We
	// follow every pointer in every activation record
	// in the RunTimeStack, marking all Objects found.
	// Before marking an Object, we make sure it is not
	// already marked, so we don't enter an infinite loop.

	// Then we sweep once through the ObjectList.  For
	// each Object in the ObjectList, if it is not marked,
	// we remove it from the list and delete it; otherwise,
	// we unmark it so it is ready for the next round of
	// mark-and-sweep.

	Mark(s);
	Sweep(s);
	}

ColorMenu::ColorMenu (const char *name, BView *_view, int h, int v, float s)
: BMenu (name, h*s, v*s)
{
	index = 0;
	for (int i = 0; i < v; i++)
		for (int j = 0; j < h; j++)
		{
			BRect cframe = BRect (j*s, i*s, (j + 1)*s, (i + 1)*s);
			AddItem (new ColorItem (system_colors()->color_list[index]), cframe);
		}
	Mark (0);
	view = _view;
	hs = h*s;
	vs = v*s;
	parent = NULL;
	fWindow = NULL;
}

//*****************************************************************************
// cascading Mark of a CustomAttribute
//*****************************************************************************
HRESULT FilterManager::MarkCustomAttribute(mdCustomAttribute cv)
{
    HRESULT     hr = NOERROR;
    CustomAttributeRec *pRec;

    // We know that the filter table is not null here.  Tell PREFIX that we know it.
    PREFIX_ASSUME(m_pMiniMd->GetFilterTable() != NULL);

    IfFailGo( m_pMiniMd->GetFilterTable()->MarkCustomAttribute( cv ) );

    // Mark the type (and any family) of the CustomAttribue.
    IfFailGo(m_pMiniMd->GetCustomAttributeRecord(RidFromToken(cv), &pRec));
    IfFailGo( Mark(m_pMiniMd->getTypeOfCustomAttribute(pRec)) );

ErrExit:
    return hr;
} // HRESULT FilterManager::MarkCustomAttribute()

void
assignAttVar(Word av, Word value, int flags ARG_LD)
{ Word a;
  mark m;

  assert(isAttVar(*av));
  assert(!isRef(*value));
  assert(gTop+8 <= gMax && tTop+6 <= tMax);
  DEBUG(CHK_SECURE, assert(on_attvar_chain(av)));

  DEBUG(1, Sdprintf("assignAttVar(%s)\n", vName(av)));

  if ( isAttVar(*value) )
  { if ( value > av )
    { Word tmp = av;
      av = value;
      value = tmp;
    } else if ( av == value )
      return;
  }

  if( !(flags & ATT_ASSIGNONLY) )
  { a = valPAttVar(*av);
    registerWakeup(av, a, value PASS_LD);
  }

  if ( (flags&ATT_WAKEBINDS) )
    return;

  Mark(m);		/* must be trailed, even if above last choice */
  LD->mark_bar = NO_MARK_BAR;
  TrailAssignment(av);
  DiscardMark(m);

  if ( isAttVar(*value) )
  { DEBUG(1, Sdprintf("Unifying two attvars\n"));
    *av = makeRef(value);
  } else if ( isVar(*value) )
  { DEBUG(1, Sdprintf("Assigning attvar with plain var\n"));
    *av = makeRef(value);			/* JW: Does this happen? */
  } else
    *av = *value;

  return;
}

int CGUIListItem::MouseLeft(float x, float y, UINT mouseState, UINT keyState)
{		// kliknuti levym tlacitkem (mouseState 0 = pusteni, 1 = stisknuti cudlitka)

	if(mouseState)
	{
		if(listBox->markListItem==this)
		{
			OnClick();
			EventArise(EClicked);
		}
		else
		{
			Mark();
		}
	}

	return 0;
}

void Registry::GarbageCollect()
{
	// unmark all objects
	MarkAll(false);

	// mark everything that is reachable from the root
	Mark(root, true);

	// everything that is not now marked is not reachable and can be deleted
	deathrow.clear();
	foreach (Instances::value_type const &val, instances)
	{
		StorageBase const *base = val.second;
		if (!base->IsMarked())
		{
			//OM_TRACE_1(4, base->GetHandle().value) << " adding to deathrow";
			deathrow.push_back(base->GetHandle());
		}
	}

void CProductCheckListBoxItem::UpdateProductItem(void)
{
	if (Mark())
	{
		m_pItem->SetFlag(PRODUCT_ITEM_Marked);
	}
	else
	{
		m_pItem->ClearFlag(PRODUCT_ITEM_Marked);
	}
	
	if (Select())
	{
		m_pItem->SetFlag(PRODUCT_ITEM_Selected);
	}
	else
	{
		m_pItem->ClearFlag(PRODUCT_ITEM_Selected);
	}
}

/* ==================================================================== */
void scTextline::MarkForDeletion( void )
{
	scXRect xrect = QueryExtents( xrect, 1 );
	
	if ( fPara && fPara->GetFirstline() == this )
		fPara->SetFirstline( 0 );

		// de-normalize extents
	if ( fColumn->GetFlowdir().IsVertical() )
		xrect.Translate( fVJOffset, 0 );	
	else								
		xrect.Translate( 0, -fVJOffset );
	
	fInkExtents 	= xrect;
	fPara			= 0; 
	fLineCount		= -1;
	fStartOffset	= -1;
	fEndOffset		= -1;
	Mark( scINVALID );
}	

static void
find_levels_r(struct block *b)
{
	int level;

	if (isMarked(b))
		return;

	Mark(b);
	b->link = 0;

	if (JT(b)) {
		find_levels_r(JT(b));
		find_levels_r(JF(b));
		level = MAX(JT(b)->level, JF(b)->level) + 1;
	} else
		level = 0;
	b->level = level;
	b->link = levels[level];
	levels[level] = b;
}

//*****************************************************************************
// cascading Mark of all GenericPar associated with a TypeDef or MethodDef token
//*****************************************************************************
HRESULT FilterManager::MarkGenericParamWithParentToken(
    mdToken     tk)
{
    HRESULT     hr = NOERROR;
    RID         ulStart, ulEnd;
    RID         index;
    GenericParamRec *pGenericParamRec;
    mdToken     constraint;
    HENUMInternal hEnum;                // To enumerate constraints.

    // Enumerate the GenericPar
    //@todo: Handle the unsorted case.
    IfFailGo( m_pMiniMd->GetGenericParamsForToken(tk, &ulStart, &ulEnd) );

    for (; ulStart < ulEnd; ++ulStart)
    {
        index = m_pMiniMd->GetGenericParamRid(ulStart);
        IfFailGo(m_pMiniMd->GetGenericParamRecord(index, &pGenericParamRec));

        RID ridConstraint;
        IfFailGo( m_pMiniMd->FindGenericParamConstraintHelper(TokenFromRid(ulStart, mdtGenericParam), &hEnum) );
        while (HENUMInternal::EnumNext(&hEnum, (mdToken *) &ridConstraint))
        {
            // Get the constraint.
            GenericParamConstraintRec *pRec;
            IfFailGo(m_pMiniMd->GetGenericParamConstraintRecord(RidFromToken(ridConstraint), &pRec));
            constraint = m_pMiniMd->getConstraintOfGenericParamConstraint(pRec);

            // Mark it.
            IfFailGo( Mark(constraint) );
        }
        HENUMInternal::ClearEnum(&hEnum);
    }

ErrExit:
    HENUMInternal::ClearEnum(&hEnum);

    return hr;
} // HRESULT FilterManager::MarkGenericParamWithParentToken()

void scContUnit::ApplyAnnotation( long			start,
								  long			end,
								  const scAnnotation&	annot )
{
	eChTranType	chTranType	= eNormalTran;
	
	if ( !fRubiArray ) {
		AllocRubiArray();
	}
	else if ( fRubiArray->IsRubiData( start, end ) ) {
		int			nth;
		int			index;
		scRubiData	rd;	
		
		fCharArray.Transform( start, end, eRemoveJapTran, end - start );
		for ( nth = 1; fRubiArray->GetNthRubi( index, rd, nth, start, end );  )
			fRubiArray->RemoveDataAt( index );
	}
	
	if ( annot.fAnnotate ) {
		scRubiData rd( annot.fCharStr, start, end, SpecAtOffset( start + 1 ) );
	
		fRubiArray->AddRubiData( rd );
		
		chTranType = eRubiTran;
	}
	else {
			// i should have already removed any annotations
		if ( fRubiArray->GetNumItems() == 0 )
			DeleteRubiArray();
		chTranType = eRemoveJapTran;
	}
	Mark( scREBREAK );
	ForceRepaint( start, end );	
	fCharArray.Transform( start, end, chTranType, end - start );
}

void StencilComp::Write (ostream& out) {
    GraphicComp::Write(out);
    UStencil* stencil = GetStencil();
    Bitmap* image, *mask;
    stencil->GetOriginal(image, mask);

    WriteBitmap(image, out);
    Mark(out);

    if (mask == nil) {
        out << no_mask;
    } else if (mask == image) {
        out << mask_equals_image;
    } else {
        out << valid_mask;
        WriteBitmap(mask, out);
    }

    WriteBgFilled(stencil->BgFilled(), out);
    WriteColor(stencil->GetFgColor(), out);
    WriteColor(stencil->GetBgColor(), out);
    WriteTransformer(stencil->GetTransformer(), out);
    WriteString(_filename, out);
}

list<class Mark> Mark::RewriteWithSimpleTokens () {
  list<Mark> ret;
  // example : <{1,2},{a,b,c},{x}> -> <{2},{c},{x}> + <{2},{b},{x}> + <{2},{a},{x}> +  <{1},{c},{x}> + <{1},{b},{x}> + <{1},{a},{x}> 
  
  list<pair <int,int> > pos;
  for (list<vector<Element> >::iterator it = elts.begin() ; it != elts.end() ; it++) {
    pos.push_back( make_pair(0,it->size()) ); 
  }  
  
  list< pair<int,int> >::iterator pit;
  list<vector<Element> >::iterator cit;
  do {
    list<vector<Element> > forret;
    
    for (pit = pos.begin(),cit = elts.begin() ; pit != pos.end() ;pit++,cit++) {
      forret.push_back(vector<Element> (1,(*cit)[pit->first]));
    }
    ret.push_back ( Mark(dom,forret,mult));
  } while (! calcSub::next(pos) );

  
  return ret;

}

cSkinDisplayReplay::cProgressBar::cProgressBar(int Width, int Height, int Current, int Total, const cMarks *Marks, tColor ColorSeen, tColor ColorRest, tColor ColorSelected, tColor ColorMark, tColor ColorCurrent)
:cBitmap(Width, Height, 2)
{
  total = Total;
  if (total > 0) {
     int p = Pos(Current);
     DrawRectangle(0, 0, p, Height - 1, ColorSeen);
     DrawRectangle(p + 1, 0, Width - 1, Height - 1, ColorRest);
     if (Marks) {
        bool Start = true;
        for (const cMark *m = Marks->First(); m; m = Marks->Next(m)) {
            int p1 = Pos(m->position);
            if (Start) {
               const cMark *m2 = Marks->Next(m);
               int p2 = Pos(m2 ? m2->position : total);
               int h = Height / 3;
               DrawRectangle(p1, h, p2, Height - h, ColorSelected);
               }
            Mark(p1, Start, m->position == Current, ColorMark, ColorCurrent);
            Start = !Start;
            }
        }
     }
}