Exemplo n.º 1
0
static void MEMArrayPtrTest()
{
	short	i,
			element;

	scMemArray *ptrArr;
	
	ptrArr = SCNEW scMemArray( sizeof(short) );

	for ( i = 0; i < 100; i++ )
		ptrArr->AppendData( (ElementPtr)&i );

	for ( i = 0; i < ptrArr->GetNumItems(); i++ ) {
		ptrArr->GetDataAt( i, (ElementPtr)&element );
		scAssert( i == element );
	}

	ptrArr->RemoveDataAt( 0 );


	for ( i = 0; i < ptrArr->GetNumItems(); i++ ) {
		ptrArr->GetDataAt( i, (ElementPtr)&element );
		scAssert( i+1 == element );
	}

	ptrArr->RemoveAll();
	
	delete ptrArr;
}
Exemplo n.º 2
0
static void MEMArrayHndTest()
{
	short	i,
			element;

	scHandleArray ptrArr( sizeof(short) );

	for ( i = 0; i < 100; i++ )
		ptrArr.AppendData( (ElementPtr)&i );

	for ( i = 0; i < ptrArr.GetNumItems(); i++ ) {
		ptrArr.GetDataAt( i, (ElementPtr)&element );
		scAssert( i == element );
	}

	ptrArr.RemoveDataAt( 0 );


	for ( i = 0; i < ptrArr.GetNumItems(); i++ ) {
		ptrArr.GetDataAt( i, (ElementPtr)&element );
		scAssert( i+1 == element );
	}

	ptrArr.RemoveAll(); 
}
Exemplo n.º 3
0
void scContUnit::scAssertValid( Bool recurse ) const
{
	scTBObj::scAssertValid();

	scAssert( !Marked( scRETABULATE ) ); 
	scAssert( !Marked( scREBREAK ) ); 

	if ( fFirstline ) {
		fFirstline->scAssertValid( false );
		scAssert( fFirstline->GetStartOffset() == 0 );
		scAssert( fFirstline->GetEndOffset() <= fCharArray.GetContentSize() );
	}
}
Exemplo n.º 4
0
void scTBObj::Insert( scTBObj* next )
{
    scTBObj* prev;

    scAssert( this && next );

    scAssert( Prev() == 0 && Next() == 0 );

    if ( ( prev = next->Prev() ) != 0 ) {
        SetPrev( prev );
        prev->SetNext( this );
    }
    next->SetPrev( this );
    SetNext( next );
}
Exemplo n.º 5
0
///////////////////////////////////////////////////////////////////////////
////sctypGoDeeper//////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Changes type of val to next in unary * operator
void sctypGoDeeper(scType * typ)
{
	if (sctypIsFunction(typ)) {
		return;					//don't change with functions
	}
/*             if ((!val->type.params)||!(val->type.params[0]))//end of type string
              {//go deeper, if possible
               if (((val->type.flags&typTYPE)!=typUSERDEFINED))//its standard or struct type:-(
                 serr3(scErr_Operand, invalid_operand_to,"","unary `*' or `->'");
//               val->sym=((scSymbol *)val->sym->add->main);
//               val->where=val->sym->add->queue;
               *typ=type->main->type;
               sctypGoDeeper(typ);

              }
              else*/
	sctypSimplifyType(typ);

	if (*(typ->params) == '*')
		(typ->params)++;
	else if (*(typ->params) == '&')
		(typ->params)++;
	else if (*(typ->params) == '[') {
		while (typ->params && *typ->params != ']')
			(typ->params)++;
		scAssert(scvalGoDeeper, *typ->params == ']');
		(typ->params)++;
	} else
		serr3(scErr_Operand, invalid_operand_to, "",
			  "unary `*' (not a pointer)");
}
Exemplo n.º 6
0
///////////////////////////////////////////////////////////////////////////
////scvalConvToInt/////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToInt(_value * val)
{
	if (scvalGetValType(val) == valINT
		|| scvalGetValType(val) == valPOINTER) return;

	deb0("ToINT\n");
	if (scvalIsImmidiate(val)) {
		switch (scvalGetValType(val)) {
		case valDOUBLE:
			val->adr.val.ival = (int) val->adr.val.dval;
			break;
		case valFLOAT:
			val->adr.val.fval = (float) val->adr.val.dval;	//???
			break;
		case valFIXED:
			val->adr.val.ival >>= 16;
			break;
		default:

			scError(scvalConvToInt);
		}
		scAssert(scvalConvToInt,
				 (val->type.flags & typTYPE) == typPREDEFINED);
		(valTYPE) val->type.main = valINT;
	} else {
Exemplo n.º 7
0
///////////////////////////////////////////////////////////////////////////
////sctypInsistsAlignment//////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
int sctypInsistsAlignment(scType * type)
{
	int i, j;
	i = sctypSizeOf(type);
	j = sctypGetValType(type);
	switch (j) {
	case valINT:
	case valDOUBLE:
	case valFLOAT:
		return 4;
	case valSHORT:
		return 2;
	case valSTRUCT:
		return sctypInsistsAlignment(&type->main->type);
	case valSCRIPT:
		return 4;
	case valPOINTER:			//depends on if it's array or pointer
		scAssert(sctypInsistsAlignment, TYPESTR);
		if (TYPESTR[0] == '*')
			return 4;			//pointer requires 4
		//array:depends on of what does it consist
		{
			scType typ2;
			typ2 = *type;
			sctypGoDeeper(&typ2);
			return sctypInsistsAlignment(&typ2);
		}
	}
	return 0;					//doesn't need alignment
}
Exemplo n.º 8
0
void scUiAlphaAnimation::createKeyFrame( u32 time, f32 alpha, scKeyFrame::InterpolationType itype /*= scKeyFrame::IT_LINEAR*/ )
{
	scAssert(alpha >= 0.f && alpha <= 1.f, "Widget alpha must in range 0 to 1! Current: " + scToString(alpha));
	scContinuousKeyFrame<f32>* keyFrame = new scContinuousKeyFrame<f32>(time, alpha);
	keyFrame->setInterpolationType(itype);
	addKeyFrame(scKeyFramePtr(keyFrame));
}
Exemplo n.º 9
0
void scTimeLine::removeRunCallBack( string const& name )
{
	auto iter = mCallBackMap.find(name);
	// 确保存在
	scAssert(iter != mCallBackMap.end(), "Timeline call back named \"" + name + "\" do not exist.");
	mCallBackMap.erase(iter);
}
Exemplo n.º 10
0
void CBaselinePositions::Init( const scMuPoint& org,
							   MicroPoint		vjOffset,
							   TypeSpec 		spec,
							   const scFlowDir& fd )
{
	scAssert( spec != 0 );
	
	MicroPoint	ptsize = scCachedStyle::GetCachedStyle( spec ).GetPtSize();
	
	if ( fd.IsHorizontal() ) {
		fTop	= org.y - scRoundMP( (REAL)ptsize * RLU_BASEfmTop / scBaseRLUsystem );
		fMiddle = org.y - scRoundMP( (REAL)ptsize * ( RLU_BASEfmTop - (scBaseRLUsystem/2)) / scBaseRLUsystem );
		fRoman	= org.y;
		fBottom = org.y + scRoundMP( (REAL)ptsize * RLU_BASEfmBottom / scBaseRLUsystem );
		
		fTop	+= vjOffset;
		fMiddle += vjOffset;
		fRoman	+= vjOffset;
		fBottom += vjOffset;
		
	}
	else {
		fLeft	= org.x - ptsize / 2;
		fMiddle = org.x;
		fRight	= org.x + ptsize / 2;
		
		fLeft	-= vjOffset;
		fMiddle -= vjOffset;
		fRight	-= vjOffset;
	}
}
Exemplo n.º 11
0
///////////////////////////////////////////////////////////////////////////
////sctypIsReference///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
bool sctypIsReference(scType * type)
{
	scAssert(sctypIsReference, type);
	if (TYPESTR && TYPESTR[0]) {
		if (TYPESTR[0] == '&')
			return true;
		if (TYPESTR[0] == '(')	//function
		{
			bool x;
			char *c = type->params;
			while (*type->params++ != ')');	//omit parameter list
			if (!*type->params)
				type->params = NULL;
			x = sctypIsReference(type);
			type->params = c;
			return x;
		}
		return false;
	} else {
		switch (type->flags & typTYPE) {
		case typUSERDEFINED:
			{
				return (sctypIsReference(&type->main->type));
			}
		default:
			return false;
		}
	}
}
Exemplo n.º 12
0
int scContUnit::ReplaceToken( const stUnivString& ustr, 
							  int32				  start, 
							  int32&			  end )
{
	ForceRepaint( start, end );	
	Mark( scREBREAK );

	if ( ustr.len == (ulong)(end - start) && fCharArray.ReplaceToken( ustr, start, end ) ) {
		fCharArray.RepairText( fSpecRun, start, end );
	}
	else if ( fCharArray.Insert( ustr, start, end ) ) {
		int32	diff = ( ustr.len - ( end - start ) );
		fSpecRun.BumpOffset( start, diff );

		end += diff;
		TypeSpec ts;
		fCharArray.Retabulate( fSpecRun, start, end, ts, 
							   fCharArray.GetContentSize() );
	}
	else {
		scAssert( 0 );
	}
#if SCDEBUG > 0
	fCharArray.Validate();
	fSpecRun.DebugRun( "ReplaceToken" );
#endif
	return 1;
}
Exemplo n.º 13
0
static long MemWrite( APPCtxPtr ctxPtr,
						void*		ptr,
						long		size )
{
	MemFileStruct*	mfs = (MemFileStruct*)ctxPtr;	


	if ( ( mfs->fBytesWritten + size ) > mfs->fTotalSize ) {
		
		mfs->fTheSysMemObj->UnlockHandle();
		
		status stat = mfs->fTheSysMemObj->SetHandleSize( mfs->fBytesWritten + size );
		if ( stat != scSuccess )
			return 0;
			
		mfs->fStartMem = (scChar*)mfs->fTheSysMemObj->LockHandle( );
		
		mfs->fTotalSize = mfs->fBytesWritten + size;
		mfs->fDstPtr	= mfs->fStartMem + mfs->fBytesWritten;
	}

	SCmemmove( mfs->fDstPtr, ptr, size );
	
	mfs->fDstPtr += size;
	
	mfs->fBytesWritten += size;
	
	scAssert( (long)(mfs->fDstPtr - mfs->fStartMem) <= mfs->fTotalSize );
	return size;
}
Exemplo n.º 14
0
/* ==================================================================== */
void scTextline::scAssertValid( BOOL recurse ) const
{ 
	scTBObj::scAssertValid(); 
	scAssert( !Marked( scINVALID ) );
	scAssert( fMaxLeadSpec != 0 );
	 
	if ( recurse ) { 
		fColumn->scAssertValid( false );
		fPara->scAssertValid( false );
	}
	else {
		scAssert( fColumn != 0 );
		scAssert( fPara != 0 );
	}
	scAssert( fStartOffset >= 0 && fEndOffset <= fPara->GetContentSize() );
}
Exemplo n.º 15
0
Bool scCOLRefData::AllocLine( Bool leadRetry )
{
	if ( leadRetry ) {
		scAssert( fPData.fTextline != 0 );
		return true;
	}

	if ( !fPData.fPrevline ) {
		fPData.fTextline = fCol->GetFirstline();
		if ( fPData.fTextline && fPData.fTextline->GetPara()->GetCount() < fPData.fPara->GetCount() ) {
			fCol->FreeLines( true, fLineDamage );
			fPData.fTextline = NULL;
		}
	}
	else
		fPData.fTextline = fPData.fPrevline->GetNext();

	if ( !fPData.fTextline ) {
		fPData.fTextline = scTextline::Allocate( fPData.fPara,
												 fCol,
												 fPData.fPrevline );
	}
	else if ( fPData.fTextline->GetPara() != fPData.fPara ) {
		fPData.fPrevline = fPData.fTextline;
		fPData.fTextline = LNInsertNew( fPData.fPara, fCol, fPData.fTextline );
	}
	else
		fPData.fTextline->InitForReuse( fPData.fPara );

	return fPData.fTextline != NULL;
}
Exemplo n.º 16
0
scMemHandle MEMResizeHndDebug( scMemHandle	obj,
							   ulong		reqSize,
							   const char*	file,
							   int	   		line )
{  
	int size1 = 0;

	if ( obj ) 
		size1 = _msize( obj );

	if ( !obj )
		obj = MEMAllocHndDebug( reqSize, file, line );
	else {
		scAssert( ((MacHandle*)obj)->Count() == 0 ); // don't resize a locked handle
		obj = (scMemHandle)realloc( obj, reqSize + sizeof( MacHandle ) );
	}

	MacHandle macHandle( obj );

	*(MacHandle*)obj = macHandle;

	int size2 = _msize( obj ) - sizeof( MacHandle );

	dbgTrackAmount( reqSize - size1 );	
	return obj;
}
Exemplo n.º 17
0
	void*	Lock( void ) 
				{ 
					Validate(); 
					scAssert( count_ >= 0 ); 
					count_++; 
					return (void*)block_; 
				}
Exemplo n.º 18
0
void scRedispList::AddCell( scColumn* col ) 
{
	scAssert( !FindCell( col ) );

	scColRedisplay colredisp( col, col->GetAPPName() );

	AppendData( (ElementPtr)&colredisp );
}
Exemplo n.º 19
0
static void BuildRepaintList( scColumn* col )
{
//	SCDebugTrace( 2, scString( "BuildRepaintList - in\n" ) );
	for ( col = (scColumn*)col->FirstInChain(); col; col = col->GetNext() ) {
		scAssert( !col->Marked( scLAYACTIVE ) );
//		scAssert( !col->Marked( scREPAINT ) );
	}
}
Exemplo n.º 20
0
/* ==================================================================== */
void scDrawLine::ProcessRenMoji()
{
	scRenMojiStr	rm;
	CharRecord		fauxChar;
	unsigned		i;
	unsigned		numChars = fChRec->flags.GetRenMoji();

		// save spec	
	rm.fSpec	= fSpec;
	
	scAssert( numChars < 7 );
	
		// process characters
	for ( i = 0; i < numChars; i++ ) {
		rm.fRenMojiStr[i] = *fChRec;
		rm.fRenMojiStr[i+1].character = 0;
		IncrementBackingStore();
	}
	
	fauxChar.Set( emSpace,	(fChRec-1)->escapement );
	SetCharArray( fauxChar, false );
	
	rm.fPosition = fCurPos;
	
	if ( fFlowDir.IsHorizontal() ) {
		switch ( scCachedStyle::GetCachedStyle().GetHorzBaseline() ) {
			case kTopBaseline:
				rm.fPosition.y = fBaselinePositions.fTop;
				break;
			case kMiddleBaseline:
				rm.fPosition.y = fBaselinePositions.fMiddle;
				break;
			case kBottomBaseline:
				rm.fPosition.y = fBaselinePositions.fBottom;
				break;
			default:
			case kRomanBaseline:
				rm.fPosition.y = fBaselinePositions.fRoman;
				break;
		}
	}
	else {
		switch ( scCachedStyle::GetCachedStyle().GetVertBaseline() ) {		
			case kLeftBaseline:
				rm.fPosition.x = fBaselinePositions.fLeft;
				break;
			default:
			case kCenterBaseline:
				rm.fPosition.x = fBaselinePositions.fMiddle;
				break;
			case kRightBaseline:
				rm.fPosition.x = fBaselinePositions.fRight;
				break;
		}			
	}
	
	fRenMojiArray.AppendData( (ElementPtr)&rm );
}
Exemplo n.º 21
0
	inline void STRVerifyCount( scContUnit* para )
	{
		long count = 0;
		
		for ( ; para; para = para->GetNext(), count++ ) {
			scAssert( count == para->GetCount() );
		}
		
	}
Exemplo n.º 22
0
///////////////////////////////////////////////////////////////////////////
////sctypIsFunction////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
bool sctypIsFunction(scType * type)
{
	scAssert(sctypIsFunction, type);
	if (!TYPESTR)
		return false;
	if (TYPESTR[0] == '(')
		return true;
	return false;
}
Exemplo n.º 23
0
///////////////////////////////////////////////////////////////////////////
////scvalConvToDouble//////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToDouble(_value * val)
{

	if (scvalGetValType(val) == valDOUBLE)
		return;

	if (scvalIsImmidiate(val)) {
		switch ((int) scvalGetValType(val)) {
		case valINT:

			val->adr.val.dval = val->adr.val.ival;
			break;
		case valFIXED:
			val->adr.val.dval = val->adr.val.ival / 65536.0;
			break;
		case valFLOAT:
			val->adr.val.dval = val->adr.val.fval;
			break;
		}
		scAssert(scvalConvToDouble,
				 (val->type.flags & typTYPE) == typPREDEFINED);
		(valTYPE) val->type.main = valDOUBLE;
	} else						//-----------------------------------------------------------
	{
		_value v1 = { { /*ADDRESS*/ 0, adrREGISTER, {0}
					   }
		, { /*type */ typPREDEFINED, NULL, (void *) valDOUBLE}, NULL };
		switch (scvalGetValType(val)) {
		case valINT:

			v1.adr.address = scvalFindFreeDoubleRegister(val);
			Gen_Opcode(opvcpuIDBL, &v1, val);
			*val = v1;
			break;
		case valSHORT:
		case valCHAR:
			scvalConvToInt(val);
			scvalConvToDouble(val);
			return;
			break;
		case valFLOAT:

			v1.adr.address = scvalFindFreeDoubleRegister(val);
			Gen_Opcode(opvcpuFDBL, &v1, val);
			*val = v1;
			break;
		case valFIXED:

			v1.adr.address = scvalFindFreeDoubleRegister(val);
			Gen_Opcode(opvcpuFIXDBL, &v1, val);
			*val = v1;
			break;
		default:
			serr2(scErr_Cast, illegal_type_conversion, " to double");
		}
	}
}
Exemplo n.º 24
0
int TextMarker::SelectEndWord(  )
{
	scAssert( fOffset <= fPara->GetContentSize() );
	
	scHandleArrayLock	h( fPara->GetCharArray() );
	CharRecordP chRec = (CharRecordP)*h;
	
	fOffset = TXTEndSelectableWord( chRec, fOffset );

	return fPara != 0;
}
Exemplo n.º 25
0
scTBObj* scTBObj::FirstInChain( void ) const
{
    scTBObj*	prev;
    scTBObj*	obj = (scTBObj*)this;

    scAssert( this != 0 );
    for ( prev = Prev(); prev; prev = obj->Prev() )
        obj = prev;

    return obj;
}
Exemplo n.º 26
0
void MEMFreeHnd( scMemHandle hnd )
{

	if ( hnd == 0 )
		return;

	MacHandle* mh = (MacHandle*)hnd;
	scAssert( !mh->Count() );

	dbgTrackAmount( -(int)_msize( hnd ) );
	
	free( hnd );	
}
Exemplo n.º 27
0
/* ===================================================================== */
int scCharArray::GetToken( USTR& ustr, 
						   int32			start, 
						   int32			end ) const
{
	scAssert( ustr.len > (ulong)(end - start) );
	scAssert( end - start > 0 );

	scHandleArrayLock	h( (scCharArray*)this );
	CharRecordP chRec = (CharRecordP)*h;
	
	chRec += start;

	int len = end - start;	 
	WCHAR* ptr = (WCHAR*)ustr.ptr;

	for ( int i = 0; i < len; i++, chRec++ )
		ptr[i] = chRec->character;
	
	ustr.len = len;
	
	return len;
}
Exemplo n.º 28
0
int TextMarker::SelectStartColumn(  )
{	
	scTextline*	txl;
	
	scAssert( fCol != 0 );	
	
	txl = fCol->GetFirstline();
	
	fTxl		= txl;
	fPara		= txl->GetPara();
	fParaCount	= fPara->GetCount();
	return SelectStartLine();
}
Exemplo n.º 29
0
///////////////////////////////////////////////////////////////////////////
////scvalConvToFloat///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToFloat(_value * val)
{
	if (scvalGetValType(val) == valFLOAT)
		return;

	deb0("ToFloat\n");
	if (scvalIsImmidiate(val)) {
		switch (scvalGetValType(val)) {
		case valDOUBLE:
			val->adr.val.fval = (float) val->adr.val.dval;
			break;
		case valINT:
			val->adr.val.fval = (float) val->adr.val.ival;
			break;
		case valFIXED:
			val->adr.val.fval = (float) (val->adr.val.ival / 65536.0);
			break;
		default:

//      (float)val->val=val->val;
//      val->vald=val->val;
			scError(scvalConvToFloat);
		}

		scAssert(scvalConvToFloat,
				 (val->type.flags & typTYPE) == typPREDEFINED);
		(valTYPE) val->type.main = valFLOAT;
	} else {
		_value v1 = { { /*ADDRESS*/ 0, adrREGISTER, {0}
					   }
		, { /*type */ typPREDEFINED, NULL, (void *) valFLOAT}, NULL };
		switch (scvalGetValType(val)) {
		case valDOUBLE:
			Gen_Opcode(opvcpuDFLT, &v1, val);
			*val = v1;
			break;
		case valSHORT:
		case valCHAR:
		case valFIXED:
		case valINT:

			scvalConvToDouble(val);
			scvalConvToFloat(val);
			return;
			break;
		default:
			serr2(scErr_Cast, illegal_type_conversion, " to float");
		}

	}
}
Exemplo n.º 30
0
void scTBObj::Write( APPCtxPtr	ctxPtr,
                     IOFuncPtr	writeFunc )
{
    uchar	abuf[FILE_SIZE_OBJECT];
    uchar*	pbuf	= abuf;

    pbuf = BufSet_long( pbuf, GetBits( ), kIntelOrder );
    pbuf = BufSet_long( pbuf, fNext ? fNext->GetEnumCount() : 0, kIntelOrder );
    pbuf = BufSet_long( pbuf, fPrev ? fPrev->GetEnumCount() : 0, kIntelOrder );

    scAssert ((size_t)(pbuf-abuf) == FILE_SIZE_OBJECT );

    WriteBytes( abuf, ctxPtr, writeFunc, FILE_SIZE_OBJECT );
}