自学教程：C++ IsObj函数代码示例

void PriorityQueueAdd(struct VMGlobals *g, PyrObject* queueobj, PyrSlot* item, double time){	PyrObject *schedq, *newschedq;	int size, maxsize;	PyrSlot *schedqSlot = queueobj->slots;	if (!IsObj(schedqSlot)) {		size = 32;		schedq = newPyrArray(g->gc, size, 0, true);		schedq->size = 1;		SetInt(schedq->slots + 0, 0); // stability count		SetObject(schedqSlot, schedq);		g->gc->GCWriteNew(queueobj, schedq); // we know schedq is white so we can use GCWriteNew	} else {		schedq = slotRawObject(schedqSlot);		maxsize = ARRAYMAXINDEXSIZE(schedq);		size = schedq->size;		if (size+3 > maxsize) {			newschedq = newPyrArray(g->gc, maxsize*2, 0, true);			newschedq->size = size;			slotCopy(newschedq->slots, schedq->slots, size);			assert(IsInt(newschedq->slots));			SetObject(schedqSlot, newschedq);			g->gc->GCWriteNew(queueobj, newschedq); // we know newschedq is white so we can use GCWriteNew			schedq = newschedq;		}	}	addheap(g, schedq, time, item);}

void PriorityQueueAdd(struct VMGlobals *g, PyrObject* queueobj, PyrSlot* item, double time){	PyrObject *schedq, *newschedq;	int size, maxsize;	PyrSlot *schedqSlot = queueobj->slots;	if (!IsObj(schedqSlot)) {		size = 16;		schedq = newPyrArray(g->gc, size, 0, true);		SetObject(schedqSlot, schedq);		g->gc->GCWrite(queueobj, schedq);	} else {		schedq = schedqSlot->uo;		maxsize = ARRAYMAXINDEXSIZE(schedq);		size = schedq->size;		if (size+2 > maxsize) {			PyrSlot *pslot, *qslot;			newschedq = newPyrArray(g->gc, maxsize*2, 0, true);			newschedq->size = size;			pslot = schedq->slots - 1;			qslot = newschedq->slots - 1;			for (int i=0; i<size; ++i) slotCopy(++qslot, ++pslot);			SetObject(schedqSlot, newschedq);			g->gc->GCWrite(queueobj, newschedq);			schedq = newschedq;		}	}	addheap(g, schedq, time, item);}

// extend/update the object with values from Val// this and Val should be an Object and not an array or something elsevoid TJsonVal::MergeObj(const PJsonVal& Val) {	EAssert(Val->IsObj() && IsObj());	for (int N = 0; N < Val->GetObjKeys(); N++) {		const TStr Key = Val->GetObjKey(N);		AddToObj(Key, Val->GetObjKey(Key));	}}

int prConnectSharedMem(VMGlobals *g, int numArgsPushed){#if !defined(SC_IPHONE)	PyrSlot *a = g->sp - 1;	PyrSlot *b = g->sp;	assert(IsObj(a));	PyrObject * self = slotRawObject(a);	int portNumber = slotRawInt(b);	int ptrIndex       = 0;	int finalizerIndex = 1;	try {		server_shared_memory_client * client = new server_shared_memory_client(portNumber);		SetPtr(self->slots + ptrIndex, client);		InstallFinalizer(g, self, finalizerIndex, disconnectSharedMem);		postfl("Shared memory server interface initialized/n");	} catch (std::exception & e) {		postfl("Cannot connect to shared memory: %s/n", e.what());		return errFailed;	}#else	postfl("Warning: Shared memory server interface disabled on iphone/n");#endif	return errNone;}

bool PyrGC::SanityClearObj(PyrObject *objA, int level){	if (!(objA->IsMarked())) return true;	if (objA->IsPermanent()) return true;	objA->ClearMark(); // unmark it	if (objA->obj_format <= obj_slot) {		// scan it		int size = objA->size;		if (size > 0) {			PyrSlot *slot = objA->slots;			for (int j=size; j--; ++slot) {				PyrObject *objB = NULL;				if (IsObj(slot) && slotRawObject(slot)) {					objB = slotRawObject(slot);				}				if (objB) {					/*if (level > 40) {						fprintf(stderr, "40 levels deep!/n");						dumpBadObject(objA);						//dumpObject((PyrObject*)objB);  //newPyrFrame						return errFailed;					}*/					bool err = SanityClearObj(objB, level+1);					if (!err) return false;				}			}		}	}	return true;}

int prSetControlBusValue(VMGlobals *g, int numArgsPushed){	PyrSlot *a = g->sp - 2;	PyrSlot *b = g->sp - 1;	PyrSlot *c = g->sp;	assert(IsObj(a));	PyrObject * self = slotRawObject(a);	int ptrIndex       = 0;	PyrSlot * ptrSlot = self->slots + ptrIndex;	if (NotPtr(ptrSlot))		return errFailed;	if (!IsInt(b))		return errFailed;	int busIndex = slotRawInt(b);	if (NotPtr(ptrSlot))		return errFailed;	float value;	int error = slotFloatVal(c, &value);	if (error != errNone)		return error;	server_shared_memory_client * client = (server_shared_memory_client*)slotRawPtr(ptrSlot);	client->get_control_busses()[busIndex] = value;	return errNone;}

int prDisconnectSharedMem(VMGlobals *g, int numArgsPushed){	PyrSlot *a = g->sp;	assert(IsObj(a));	PyrObject * self = slotRawObject(a);	return disconnectSharedMem(g, self);}

Ref * sysVectorAppend( Ref * pc, class MachineClass * vm ) {	//	Variables here would be unaffected by a GC.	unsigned long N;	unsigned long lhs_n;	unsigned long rhs_n;	if ( vm->count != 2 ) throw Ginger::Mishap( "Wrong number of arguments in vectorAppend" );	{			//	May need to GC so leave on the stack.		Ref rhs = vm->fastPeek();		Ref lhs = vm->fastPeek( 1 );				if ( !IsObj( lhs ) || !IsObj( rhs ) ) throw Ginger::Mishap( "Invalid arguments in vectorAppend" );				Ref * lhs_K = RefToPtr4( lhs );		Ref * rhs_K = RefToPtr4( rhs );		Ref lhs_key = *lhs_K;		Ref rhs_key = *rhs_K;				if ( lhs_key != rhs_key || !IsSimpleKey( lhs_key ) || KindOfSimpleKey( lhs_key ) != VECTOR_KIND ) throw Ginger::Mishap( "Invalid arguments in vectorAppend" );			lhs_n = sizeAfterKeyOfVectorLayout( lhs_K );		rhs_n = sizeAfterKeyOfVectorLayout( rhs_K );		N = lhs_n + rhs_n;		}		XfrClass xfr( vm->heap().preflight( pc, N + 2 ) );	//	No risk of GC so safe to pop.	Ref * rhs_K = RefToPtr4( vm->fastPop() );	Ref * lhs_K = RefToPtr4( vm->fastPop() );	xfr.xfrRef( ULongToSmall( N ) );	xfr.setOrigin();	xfr.xfrRef( *lhs_K );	xfr.xfrCopy( lhs_K + 1, lhs_n );	xfr.xfrCopy( rhs_K + 1, rhs_n );	vm->fastPush( xfr.makeRef() );	return pc;}

void PriorityQueueClear(PyrObject *queueobj){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = schedqSlot->uo;		schedq->size = 0;	}}

void PriorityQueueClear(PyrObject *queueobj){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = slotRawObject(schedqSlot);		SetInt(schedq->slots, 0); // stability count		schedq->size = 1;	}}

void PriorityQueuePostpone(PyrObject* queueobj, double time){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = slotRawObject(schedqSlot);		PyrSlot* slots = schedq->slots;		for (int i=1; i < schedq->size; i+=3) {			SetRaw(&slots[i], slotRawFloat(&slots[i]) + time);		}	}}

void PriorityQueuePostpone(PyrObject* queueobj, double time){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = schedqSlot->uo;		PyrSlot* slots = schedq->slots;		for (int i=0; i < schedq->size; i+=2) {			slots[i].uf += time;		}	}}

bool PriorityQueueEmpty(PyrObject *queueobj){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = slotRawObject(schedqSlot);		if (schedq->size > 1) {			return false;		}	}	return true;}

void PyrGC::Finalize(PyrObject *finalizer){	if (!IsPtr(finalizer->slots+0)) return;	if (!IsObj(finalizer->slots+1)) return;	ObjFuncPtr func = (ObjFuncPtr)finalizer->slots[0].ui;	PyrObject *obj = finalizer->slots[1].uo;	//post("FINALIZE %s %p/n", obj->classptr->name.us->name, obj);	(func)(mVMGlobals, obj);	SetNil(obj->slots+0);	SetNil(obj->slots+1);}

void PyrGC::Finalize(PyrObject *finalizer){	if (!IsPtr(finalizer->slots+0)) return;	if (!IsObj(finalizer->slots+1)) return;	ObjFuncPtr func = (ObjFuncPtr)slotRawPtr(&finalizer->slots[0]);	PyrObject *obj = slotRawObject(&finalizer->slots[1]);	//post("FINALIZE %s %p/n", slotRawSymbol(&obj->classptr->name)->name, obj);	(func)(mVMGlobals, obj);	SetNil(obj->slots+0);	SetNil(obj->slots+1);}

////	This computes obj_C = obj_Z - obj_A from obj_K//unsigned long lengthAfterObjectKey( Ref * obj_K ) {	//	Keys fall into the following categories: FunctionKey, SimpleKey, Pointer to Keys	Ref key = *obj_K;	if ( IsSimpleKey( key ) ) {		switch ( LayoutOfSimpleKey( key ) ) {		//switch ( KindOfSimpleKey( key ) ) {			case RECORD_LAYOUT: {			//case MAP_KIND:			//case PAIR_KIND:			//case RECORD_KIND: {				assert( LayoutOfSimpleKey( key ) == RECORD_LAYOUT );				assert( KindOfSimpleKey( key ) == PAIR_KIND || KindOfSimpleKey( key ) == MAP_KIND  || KindOfSimpleKey( key ) == RECORD_KIND );				return sizeAfterKeyOfRecordLayout( obj_K );				break;			}			case VECTOR_LAYOUT: {			//case VECTOR_KIND: {				assert( LayoutOfSimpleKey( key ) == VECTOR_LAYOUT );				assert( KindOfSimpleKey( key ) == VECTOR_KIND );				return sizeAfterKeyOfVectorLayout( obj_K );				break;			}			case MIXED_LAYOUT: {				assert( LayoutOfSimpleKey( key ) == MIXED_LAYOUT );				return sizeAfterKeyOfMixedLayout( obj_K );				break;			}			case STRING_LAYOUT: {			//case STRING_KIND: {				assert( LayoutOfSimpleKey( key ) == STRING_LAYOUT );				assert( KindOfSimpleKey( key ) == STRING_KIND );				return sizeAfterKeyOfStringLayout( obj_K );				break;			}			case WRECORD_LAYOUT: {				assert( LayoutOfSimpleKey( key ) == WRECORD_LAYOUT );				return sizeAfterKeyOfWRecordLayout( obj_K );				break;			}			default: 				throw UnreachableError();		}	} else if ( IsFunctionKey( key ) ) {		return sizeAfterKeyOfFn( obj_K );	} else if ( IsObj( key ) ) {		return sizeAfterKeyOfInstance( obj_K );	} else {		throw Ginger::Mishap( "Cannot take length of this" );	}}

void PriorityQueuePop(VMGlobals *g, PyrObject *queueobj, PyrSlot *result){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = slotRawObject(schedqSlot);		double time;		if (!getheap(g, schedq, &time, result)) {			SetNil(result);		}	} else {		SetNil(result);	}}

void PriorityQueueTop(PyrObject *queueobj, PyrSlot *result){	PyrSlot *schedqSlot = queueobj->slots;	if (IsObj(schedqSlot)) {		PyrObject *schedq = slotRawObject(schedqSlot);		if (schedq->size > 1) {			slotCopy(result,&schedq->slots[1]);		} else {			SetNil(result);		}	} else {		SetNil(result);	}}

imeth objrtn ObjectPool_im_gDisposeObject(object self, object obj){ ObjectPool_iv_t *iv = GetIVs(ObjectPool, self);	object pobj = gNewWithPtr(Pointer, obj); 	object val = gFindValue(iv->iObjects, pobj); 	if (val) { 		if (IsObj(obj)) { 			long v1 = gObjectSerialNumber(obj); 			long v2 = gLongValue(gValue(val)); 			if (v1 == v2) 				gShortValue(gKey(val)) ? gDeepDispose(obj) : gDispose(obj); 		} 		gDeepDisposeObj(iv->iObjects, pobj); 	} 	gDispose(pobj); 	return NULL; } 

////	This computes obj_K from obj_A. //Ref * findObjectKey( Ref * obj_A ) {	//	Cases are that 'obj_A' is pointing at	//		1.	FnLengthKey.	//		2.	NonKey* Key series	if ( IsFnLength( *obj_A ) ) {		//	We are at the start of a function.		//	It has a fixed offset to the key.		return obj_A + OFFSET_FROM_FN_LENGTH_TO_KEY;	} else {		for ( int n = 0; n < MAX_OFFSET_FROM_START_TO_KEY; n++ ) {			//			//	Note that this function is called on objects that have been			//	forwarded but not yet scanned by the GC. So the test for the			//	key has to be capable of coping with a forwarded key. This			//	test is stupider and restricts values in front of the key to			//	simple values.			//			//	A smarter test is 			//		1. 	Are you a simple key? Job done. A: yes			//		2.	Are you an object? Define K = *you			//			2a.	Is *K the keykey? If so job done. A: yes			//			2b. Is *K forwarded? Define F = *K			//			2c.	Is *F the keykey? If so A: yes			//		3. 	Otherwise done A: no			//				/*	I think the code would look like this.			if ( IsSimpleKey( *obj_A ) ) return obj_A;			if ( IsObj( *obj_A ) ) {				if ( *RefToPtr4( *obj_A ) == sysClassKey ) return obj_A;			}			if ( IsFwd( *obj_A ) ) {				Ref K = *FwdToPtr4( *obj_A );				if ( IsObj( K ) ) {					if ( *RefToPtr4( K ) == sysClassKey ) return obj_A;				}			} 			*/			Ref * x = obj_A + n;			Ref k = *x;			if ( IsSimpleKey( k ) || IsObj( k ) || IsFwd( k ) ) {				return x;			}		}		throw UnreachableError();	}}

int prNetAddr_SendRaw(VMGlobals *g, int numArgsPushed){	PyrSlot* netAddrSlot = g->sp - 1;	PyrSlot* arraySlot = g->sp;	PyrObject* netAddrObj = netAddrSlot->uo;	if (!IsObj(arraySlot) || !isKindOf(arraySlot->uo, class_rawarray)) {		error("sendRaw arg must be a kind of RawArray./n");		return errWrongType;	}	PyrObject *array = arraySlot->uo;	char *bufptr = (char*)array->slots;	int32 msglen = array->size * gFormatElemSize[array->obj_format];	return netAddrSend(netAddrObj, msglen, bufptr, false);}

HOT void PyrGC::ScanSlots(PyrSlot *inSlots, long inNumToScan){	if (inNumToScan == 0)		return;	unsigned char whiteColor = mWhiteColor;	unsigned char greyColor  = mGreyColor;	mSlotsScanned += inNumToScan;	int foundGreyObjects = 0;	PyrObjectHdr * grey     = &mGrey;	PyrObjectHdr * greyNext = grey->next;	PyrSlot *slot = inSlots;	PyrSlot *endslot = inSlots + inNumToScan;	do {		if (IsObj(slot)) {			PyrObject *obj = slotRawObject(slot);			if (obj->gc_color == whiteColor) {				/* used to be ToGrey2(obj), but rearranged for slightly better performance				 *				 * move obj from white to grey */				PyrObjectHdr * objPrev  = obj->prev;				PyrObjectHdr * objNext  = obj->next;				/* link in grey set */				greyNext->prev = obj;				grey->next = obj;				obj->prev = grey;				obj->next = greyNext;				greyNext = obj;				// remove from old set				objNext->prev = objPrev;				objPrev->next = objNext;				obj->gc_color = greyColor;				foundGreyObjects++;			}		}		++slot;	} while (slot != endslot);	mNumGrey += foundGreyObjects;}

bool PyrGC::BlackToWhiteCheck(PyrObject *objA){	if (objA->obj_format > obj_slot) return true;	// scan it	int size = objA->size;	if (size > 0) {		PyrSlot *slot = objA->slots;		for (int j=size; j--; ++slot) {			PyrObject * objB = NULL;			if (IsObj(slot) && slotRawObject(slot)) {				objB = slotRawObject(slot);			}			if (objB && (unsigned long)objB < 100) {				fprintf(stderr, "weird obj ptr/n");				return false;			}			if (objB) {				if (objA == mStack)					continue;				if (objA->gc_color == mBlackColor && objA != mPartialScanObj) {					if (objB->gc_color == mWhiteColor) {						if (objA->classptr == class_frame) {							// jmc: black stack frames pointing to white nodes can be ignore							PyrFrame * frameA = (PyrFrame*)objA;							PyrMethod * meth = slotRawMethod(&frameA->method);							PyrMethodRaw * methraw = METHRAW(meth);							if (methraw->needsHeapContext)								continue;						}#if DUMPINSANITY						fprintf(stderr, "black frame to white ref %p %p/n", objA, objB);						dumpBadObject(objA);						dumpBadObject(objB);						fprintf(stderr, "/n");#endif						return false;					}				}			}		}	}	return true;}

int prSymbol_envirGet(struct VMGlobals *g, int numArgsPushed){	PyrSlot *a, result;	int objClassIndex;	a = g->sp;  // key	PyrSlot* currentEnvironmentSlot = &g->classvars->slots[1];	PyrObject *dict = slotRawObject(currentEnvironmentSlot);	if (!IsObj(currentEnvironmentSlot)) return errFailed;	if (!ISKINDOF(dict, class_identdict_index, class_identdict_maxsubclassindex)) return errFailed;	identDict_lookup(dict, a, calcHash(a), &result);	slotCopy(a,&result);	return errNone;}

int prSymbol_envirPut(struct VMGlobals *g, int numArgsPushed){	PyrSlot *a, *b;	int objClassIndex;	a = g->sp - 1;  // key	b = g->sp;  // value	PyrSlot* currentEnvironmentSlot = &g->classvars->slots[1];	PyrObject *dict = slotRawObject(currentEnvironmentSlot);	if (!IsObj(currentEnvironmentSlot)) return errFailed;	if (!ISKINDOF(dict, class_identdict_index, class_identdict_maxsubclassindex)) return errFailed;	int err = identDictPut(g, dict, a, b);	if (err) return err;	slotCopy(a,b);	return errNone;}

int prGetControlBusValues(VMGlobals *g, int numArgsPushed){	PyrSlot *a = g->sp - 2;	PyrSlot *b = g->sp - 1;	PyrSlot *c = g->sp;	assert(IsObj(a));	PyrObject * self = slotRawObject(a);	int ptrIndex       = 0;	PyrSlot * ptrSlot = self->slots + ptrIndex;	if (NotPtr(ptrSlot))		return errFailed;	if (!IsInt(b))		return errFailed;	int busIndex = slotRawInt(b);	if (!IsInt(c))		return errFailed;	int numberOfChannels = slotRawInt(c);	server_shared_memory_client * client = (server_shared_memory_client*)slotRawPtr(ptrSlot);	PyrObject * ret = newPyrArray(g->gc, numberOfChannels, 0, 1);	ret->size = numberOfChannels;	for (int i = 0; i != numberOfChannels; ++i) {		float value = client->get_control_busses()[busIndex + i];		SetFloat(ret->slots+i, value);	}	SetObject(a, ret);	return errNone;}

inline bool IsSignal(PyrSlot* slot) { return (IsObj(slot) && slotRawObject(slot)->classptr == class_signal); }

void TJsonVal::GetObjStrV(const char *Key, TStrV& StrV) const {  EAssertR(IsObj(), "Cannot get property of non-object!");  EAssertR(IsObjKey(Key), "Unknown key: " + TStr(Key));  GetObjKey(Key)->GetArrStrV(StrV);}