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

/*===========================================================================*/ |	This swaps the position of 2 morphs in the channel list |  /*===========================================================================*/Value*wm3_MoveMorph_cf(Value** arg_list, int count){	check_arg_count(wm3_MoveMorph_cf, 3, count);	type_check(arg_list[0], MAXModifier, _T("WM3_MoveMorph [Morpher Modifier] [Morph Source Index] [Morph Destination Index]"));	type_check(arg_list[1], Integer, _T("WM3_MoveMorph [Morpher Modifier] [Morph Source Index] [Morph Destination Index]"));	type_check(arg_list[2], Integer, _T("WM3_MoveMorph [Morpher Modifier] [Morph Source Index] [Morph Destination Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int morphIndexA = arg_list[2]->to_int(); 	morphIndexA--;	if(morphIndexA>=100) morphIndexA = 99;	if(morphIndexA<0) morphIndexA = 0;	int morphIndexB = arg_list[1]->to_int(); 	morphIndexB--;	if(morphIndexB>=100) morphIndexB = 99;	if(morphIndexB<0) morphIndexB = 0;		MaxMorphModifier maxMorpher(mp);	bool res = maxMorpher.MoveMorphChannel(morphIndexA, morphIndexB);	maxMorpher.RefreshChannelsUI();	return (res ? &true_value : &false_value);}

/*===========================================================================*/ |	Sets the the  progressive morph tension |  /*===========================================================================*/Value*wm3_SetProgressiveMorphTension_cf(Value** arg_list, int count){	check_arg_count(wm3_SetProgressiveMorphTension_cf, 3, count);	type_check(arg_list[0], MAXModifier, _T("WM3_SetProgressiveMorphTension [Morpher Modifier] [Morph Index] [Tension]"));	type_check(arg_list[1], Integer, _T("WM3_SetProgressiveMorphTension [Morpher Modifier] [Morph Index] [Tension]"));	type_check(arg_list[2], Float, _T("WM3_SetProgressiveMorphTension [Morpher Modifier] [Morph Index] [Tension]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int morphIndex = arg_list[1]->to_int(); 	morphIndex--;	if(morphIndex>=100) morphIndex = 99;	if(morphIndex<0) morphIndex = 0;	float tension = arg_list[2]->to_float(); 	INode *node = NULL;	MaxMorphModifier maxMorpher(mp);	bool res = maxMorpher.GetMorphChannel(morphIndex).SetProgressiveMorphTension(tension);	mp->Update_channelParams();	return (res ? &true_value : &false_value);}

Value*wm3_mc_settarget_cf(Value** arg_list, int count){	check_arg_count(wm3_mc_settarget, 3, count);	type_check(arg_list[0], MAXModifier, _T("WM3_MC_SetTarget [Morpher Modifier] [Channel Index] [Node]"));	type_check(arg_list[1], Integer, _T("WM3_MC_SetTarget [Morpher Modifier] [Channel Index] [Node]"));	type_check(arg_list[2], MAXNode, _T("WM3_MC_SetTarget [Morpher Modifier] [Channel Index] [Node]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	int sel = arg_list[1]->to_int(); sel -= 1;	if(sel>=100) sel = 99;	if(sel<0) sel = 0;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	INode *node = NULL;		node = arg_list[2]->to_node(); 	if (node == NULL) return &false_value;	MaxMorphModifier maxMorpher(mp);	MaxMorphChannel maxMorphChannel = maxMorpher.GetMorphChannel(sel);	if (NULL != maxMorphChannel.GetMorphTarget()) return &false_value;		if (maxMorphChannel.SetMorphTarget(node, MAXScript_time()))	{		return &true_value;	}	return &false_value;}

Value*wm3_DeleteMarker_cf(Value** arg_list, int count){	check_arg_count(wm3_DeleteMarker_cf, 2, count);	type_check(arg_list[0], MAXModifier, _T("wm3_DeletMarker [Morpher Modifier] [Morph Index]"));	type_check(arg_list[1], Integer, _T("wm3_DeletMarker [Morpher Modifier] [Morph Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int sel = arg_list[1]->to_int(); 	sel -= 1;	if ( (sel >= 0) && (sel < mp->markerName.Count()))	{#pragma warning (push)#pragma warning (disable: 4996)		IMorphClass imp;		imp.HoldMarkers(mp);#pragma warning (pop)		mp->markerName.Delete(sel,1);		mp->markerIndex.Delete(sel,1);		mp->Update_channelMarkers();		return &true_value;	}	return &false_value;}

/*===========================================================================*/ |	Returns the the  progressive morph Node |  /*===========================================================================*/Value*wm3_GetProgressiveMorphNode_cf(Value** arg_list, int count){	check_arg_count(wm3_GetProgressiveMorphNode_cf, 3, count);	type_check(arg_list[0], MAXModifier, _T("WM3_GetProgressiveMorphNode [Morpher Modifier] [Morph Index] [Progressive Morph Index]"));	type_check(arg_list[1], Integer, _T("WM3_GetProgressiveMorphNode [Morpher Modifier] [Morph Index]  [Progressive Morph Index]"));	type_check(arg_list[2], Integer, _T("WM3_GetProgressiveMorphNode [Morpher Modifier] [Morph Index]  [Progressive Morph Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int morphIndex = arg_list[1]->to_int(); 	morphIndex--;	if(morphIndex>=100) morphIndex = 99;	if(morphIndex<0) morphIndex = 0;	int pMorphIndex = arg_list[2]->to_int(); 	pMorphIndex--;	MaxMorphModifier maxMorpher(mp);	INode *node = maxMorpher.GetMorphChannel(morphIndex).GetProgressiveMorphTarget(pMorphIndex);	if (node != NULL)	{		return MAXNode::intern(node);		}	return &undefined;}

Value*wm3_CreateMarker_cf(Value** arg_list, int count){	check_arg_count(wm3_CreateMarker_cf, 3, count);	type_check(arg_list[0], MAXModifier, _T("wm3_CreateMarker [Morpher Modifier] [Morph Index] [Marker Name]"));	type_check(arg_list[1], Integer, _T("wm3_CreateMarker [Morpher Modifier] [Morph Index] [Marker Name]"));	type_check(arg_list[2], String, _T("wm3_CreateMarker [Morpher Modifier] [Morph Index] [Marker Name]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int sel = arg_list[1]->to_int(); 	sel -= 1;	const TCHAR *name = arg_list[2]->to_string();	if (sel >= 0) 	{#pragma warning (push)#pragma warning (disable: 4996)		IMorphClass imp;		imp.HoldMarkers(mp);#pragma warning (pop)		mp->markerName.AddName(name);		mp->markerIndex.Append(1,&sel,0);		mp->Update_channelMarkers();		return &true_value;	}	return &false_value;}

static SExp subr_get_raw_value(int s, int argnum) {	SExp buf = vm_stack_ref(s, 0);	SFixnum ofs = S2FIXNUM(type_check(vm_stack_ref(s, 1), &TFixnum));	SExp type = type_check(vm_stack_ref(s, 2), &TSymbol);	char* ptr;	if (s2ptr((char*)&ptr, buf) == NULL) {		return error("Illegal type");	} else {		if (eq(type, intern("int"))) {			return fixnum2s(*(int*)(ptr + ofs));		} else if (eq(type, intern("int32"))) {			return fixnum2s(*(int*)(ptr + ofs));		} else if (eq(type, intern("int16"))) {			return fixnum2s(*(short*)(ptr + ofs));		} else if (eq(type, intern("int8"))) {			return fixnum2s(*(char*)(ptr + ofs));		} else if (eq(type, intern("uint32"))) {			return fixnum2s(*(unsigned int*)(ptr + ofs));		} else if (eq(type, intern("uint16"))) {			return fixnum2s(*(unsigned short*)(ptr + ofs));		} else if (eq(type, intern("uint8"))) {			return fixnum2s(*(unsigned char*)(ptr + ofs));		} else {			return error("Illegal type");		}	}}

/*===========================================================================*/ |	Deletes a progressives Morph |  /*===========================================================================*/Value*wm3_DeleteProgressiveMorphNode_cf(Value** arg_list, int count){	check_arg_count(wm3_DeleteProgressiveMorphNode, 3, count);	type_check(arg_list[0], MAXModifier, _T("WM3_DeleteProgressiveMorphNode [Morpher Modifier] [Morph Index] [Progressive Morph Index]"));	type_check(arg_list[1], Integer, _T("WM3_DeleteProgressiveMorphNode [Morpher Modifier] [Morph Index] [Progressive Morph Index]"))		type_check(arg_list[2], Integer, _T("WM3_DeleteProgressiveMorphNode [Morpher Modifier] [Morph Index] [Progressive Morph Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int morphIndex = arg_list[1]->to_int(); 	morphIndex--;	if(morphIndex>=100) morphIndex = 99;	if(morphIndex<0) morphIndex = 0;	int pMorphIndex = arg_list[2]->to_int(); 	pMorphIndex--;	MaxMorphModifier maxMorpher(mp);	bool res = maxMorpher.GetMorphChannel(morphIndex).DeleteProgressiveMorphTarget(pMorphIndex);	return (res ? &true_value : &false_value);}

static SExp subr_make_c_function(int s, int argnum) {	SExp ret_type = type_check(vm_stack_ref(s, 0), &TSymbol);	SExp sproc = type_check(vm_stack_ref(s, 1), &TCPtr);	SExp arg_types = vm_stack_ref(s, 2);	void* proc = ((CPtr*)S2PTR(sproc))->ptr;	return make_cfunc(proc, ret_type, arg_types);}

/*===========================================================================*/ |	Returns the the  progressive morph weight |  /*===========================================================================*/Value*wm3_SetProgressiveMorphWeight_cf(Value** arg_list, int count){	check_arg_count(WM3_SetProgressiveMorphWeight_cf, 4, count);	type_check(arg_list[0], MAXModifier, _T("WM3_SetProgressiveMorphWeight [Morpher Modifier] [Morph Index] [Progressive Node] [Weight]"));	type_check(arg_list[1], Integer, _T("WM3_SetProgressiveMorphWeight [Morpher Modifier] [Morph Index]  [Progressive Node] [Weight]"));	type_check(arg_list[2], MAXNode, _T("WM3_SetProgressiveMorphWeight [Morpher Modifier] [Morph Index]  [Progressive Node] [Weight]"));	type_check(arg_list[3], Float, _T("WM3_SetProgressiveMorphWeight [Morpher Modifier] [Morph Index]  [Progressive Node] [Weight]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int morphIndex = arg_list[1]->to_int(); 	morphIndex--;	if(morphIndex>=100) morphIndex = 99;	if(morphIndex<0) morphIndex = 0;	INode *node = NULL;		node = arg_list[2]->to_node(); 	float weight = arg_list[3]->to_float(); 	if (node == NULL) return &false_value;		MaxMorphModifier maxMorpher(mp);	int pMorphCount = maxMorpher.GetMorphChannel(morphIndex).NumProgressiveMorphTargets();		int pMorphIndex = -1;	if (node == (INode*)mp->GetReference(101+morphIndex))	{		pMorphIndex = 0;	}	else	{		for (int i = 1; i < (pMorphCount); i++)		{			int refnum = 200+i+morphIndex*MAX_PROGRESSIVE_TARGETS;			if (node == (INode*)mp->GetReference(refnum))			{				pMorphIndex = i ;				break;			}		}	}	bool res = maxMorpher.GetMorphChannel(morphIndex).SetProgressiveMorphWeight(pMorphIndex, weight);	if (res)		{		mp->Update_channelFULL();		mp->Update_channelParams();	}	return (res ? &true_value : &false_value);}

static SExp subr_get_proc_adr(int s, int argnum) {	SExp h = type_check(vm_stack_ref(s, 0), &TCPtr);	SExp proc_name = type_check(vm_stack_ref(s, 1), &TString);	HDLL_MODULE hDll = (HDLL_MODULE)((CPtr*)S2PTR(h))->ptr;	void* proc_adr = get_proc_adr(hDll, S2CSTR(proc_name));	if (proc_adr == NULL) {		return sFALSE;	} else {		return gen_cptr(proc_adr);	}}

/*}}}*/static void process_subsentence(TreeNode *ss, TermVector *pre, TermVector *post)/*{{{*/{  struct nonterm *nt, *ntc;  int nc;  TreeNode *sss;  TreeNode *c;  TermVector head_terms, new_pre;  TreeNode *terms, *btail;  sss = ss;  do {    type_check(ss, SUBSENTENCE);    nt = &sss->data.nonterm;    nc = nt->nchildren;    if (nc == 2) {      /* Pick the 'subsentence' following the 'prenex' out of the 2 child version */      sss = child_ref(sss, 1);    } else {      /* Pick 'sentence' out of the 1 child version */      sss = child_ref(sss, 0);    }  } while (nc == 2);  type_check(sss, SENTENCE);  nt = &sss->data.nonterm;  if (nt->nchildren == 1) {    c = nt->children[0];    if (c->type == N_NONTERM) {      ntc = & c->data.nonterm;      if ((ntc->type == NO_CU_SENTENCE) || (ntc->type == OBSERVATIVE_SENTENCE)) {        sss = c;        nt = ntc;      }    }  }  /* Now looking at the '[terms [CU #]] bridi_tail' node. */  terms = find_nth_child(sss, 1, TERMS);  btail = find_nth_child(sss, 1, BRIDI_TAIL);  assert(btail); /* Every sentence has one of these! */  if (terms) {    tv_build(&head_terms, terms);    tv_catenate(pre, &head_terms, &new_pre);    process_bridi_tail(btail, &new_pre, post);  } else {    process_bridi_tail(btail, pre, post);  }}

/*===========================================================================*/ |	Returns the the  progressive morph weight |  /*===========================================================================*/Value*wm3_GetProgressiveMorphWeight_cf(Value** arg_list, int count){	check_arg_count(wm3_GetProgressiveMorphWeight_cf, 3, count);	type_check(arg_list[0], MAXModifier, _T("WM3_GetProgressiveMorphWeight [Morpher Modifier] [Morph Index] [Progressive Node]"));	type_check(arg_list[1], Integer, _T("WM3_GetProgressiveMorphWeight [Morpher Modifier] [Morph Index]  [Progressive Node]"));	type_check(arg_list[2], MAXNode, _T("WM3_GetProgressiveMorphWeight [Morpher Modifier] [Morph Index]  [Progressive Node]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	int morphIndex = arg_list[1]->to_int(); 	morphIndex--;	if(morphIndex>=100) morphIndex = 99;	if(morphIndex<0) morphIndex = 0;	INode *node = NULL;		node = arg_list[2]->to_node(); 	float weight = 0.0f;	if (node == NULL) return Float::intern(weight);			MaxMorphModifier maxMorpher(mp);	int pMorphCount = maxMorpher.GetMorphChannel(morphIndex).NumMaxProgressiveTargets();					int pMorphIndex = -1;	if (node == (INode*)mp->GetReference(101+morphIndex))	{		pMorphIndex = 0;	}	else	{		for (int i = 1; i < (pMorphCount); i++)		{			int refnum = 200+i+morphIndex*MAX_PROGRESSIVE_TARGETS;			if (node == (INode*)mp->GetReference(refnum))			{					pMorphIndex = i ;					break;			}		}	}	weight = maxMorpher.GetMorphChannel(morphIndex).GetProgressiveMorphWeight(pMorphIndex);	return Float::intern(weight);	}

Value* ExportCalSkel_cf(Value** arg_list, int count){		int			i;	INodeTab	tabnode;	std::tstring fullpathfilename;	int			ArraySize		;	bool		bShowUI			;	check_arg_count(ExportCalSkel, 3, count);	type_check(arg_list[0], String, _T("[The first argument of ExportCalSkel should be a string that is a full path name of the file to export]"));	type_check(arg_list[1], Array , _T("[The 2nd argument of ExportCalSkel should be an array of nodes]"));	type_check(arg_list[2], Boolean,_T("[The 3rd argument of ExportCalSkel should be a boolean that tells if you want to use the UI or not to select nodes of skeleton]"));		try	{		fullpathfilename	= arg_list[0]->to_string();		//Get Array		Array* BonesArray	= static_cast<Array*>(arg_list[1]);		ArraySize			= BonesArray->size;			bShowUI				= !!(arg_list[2]->to_bool());		if (fullpathfilename.length() == 0) return new Integer (1);		if (! ArraySize)		return new Integer (2); 		for (i=0;i<ArraySize;i++)		{			if (BonesArray->data[i]->is_kind_of(class_tag(MAXNode)) )			{				INode* _node	= 	BonesArray->data[i]->to_node();				if (! _node)return new Integer (3);				tabnode.Append(1,&_node);			}		}		//Call the exporter from Maxscript		if (CMaxSkeletonExport::ExportSkeletonFromMaxscriptCall(fullpathfilename.c_str(), tabnode, bShowUI) )			return new Integer (0);		return new Integer (-1);	}	catch(...)	{			//MessageBox(NULL,"Exception catched in ExportCalSkel C++ function","Error",MB_OK);		return new Integer (-2);	}}

Value*wm3_setscrollpos_cf(Value** arg_list, int count){	check_arg_count(wm3_setscrollpos, 2, count);	type_check(arg_list[0], MAXModifier, "WM3_SetChannelPos [Morpher Modifier] [NewPos]");	type_check(arg_list[1], Integer, "WM3_SetChannelPos [Morpher Modifier] [NewPos]");	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	mp->VScroll(SB_THUMBPOSITION,(arg_list[1]->to_int()-1));	return &true_value;}

 /** create from Py functions.  * in most of cases, need not to inc ref.  * please read python doc carefully  */ set(PyObject* p, bool borrowed = false) {     type_check(p);     _p = p;     if(borrowed)         Py_XINCREF(_p); }

Value*triangle_cf(Value** arg_list, int count){	check_arg_count(triangle, 2, count);	for (int i=0; i < count; i++)		type_check(arg_list[i], Array, _T("triangle"));	Array			*pts_val = (Array*)arg_list[0], 	*col_val = (Array*)arg_list[1];	GraphicsWindow	*gw		 = MAXScript_interface->GetActiveViewExp().getGW();			if (MaxSDK::Graphics::IsRetainedModeEnabled() && gw->querySupport(GW_SPT_NUM_LIGHTS) == 0)	{		return &undefined;	}	if (col_val->size != 3)		throw RuntimeError(MaxSDK::GetResourceStringAsMSTR(IDS_RK_RGB_ARRAY_SIZE_NOT_3));	if (pts_val->size != 3)		throw RuntimeError(MaxSDK::GetResourceStringAsMSTR(IDS_RK_VERT_ARRAY_SIZE_NOT_3));	Point3* pts = new Point3[3]; 	Point3*	 col = new Point3[3]; 	for (int i=0; i < 3; i++) {		pts[i] = pts_val->data[i]->to_point3();		col[i] = col_val->data[i]->to_point3()/255.f;	}		//	virtual void	triangle(Point3 *xyz, Point3 *rgb) = 0;	gw->triangle(pts, col);	delete [] pts;	delete [] col;	return &ok;}

ConditionalNode::ConditionalNode(const std::shared_ptr<AstNode> &condition_,                                 const std::shared_ptr<AstNode> &then_part_,                                 const std::shared_ptr<AstNode> &else_part_)    : condition(condition_), then_part(then_part_), else_part(else_part_) {  type_check(condition, BOOL);  type_check_match(then_part, else_part);}

Value*my_file_in_cf(Value** arg_list, int count){	// myFileIn "filename" [quiet:true]	// pick up arguments	check_arg_count_with_keys(myFileIn, 1, count);	two_typed_value_locals(ReadonlyTextFileStream* file, Value* result);	Value* quiet = key_arg_or_default(quiet, &true_value);	type_check(quiet, Boolean, _T("myFileIn quiet:"));	// open a fileStream instance on the file	vl.file = new ReadonlyTextFileStream();	vl.file = vl.file->open(arg_list[0]->to_string());	if (vl.file == (CharStream*)&undefined)		throw RuntimeError (_T("fileIn cannot open file: "), arg_list[0]);	// pass it to the stream-based fileIn utility function	try	{		vl.result = file_in(vl.file, (quiet == &true_value));	}	catch (...)	{		// catch any errors and close the temp filestream		vl.file->close();		throw;	}	// pop value locals & return fileIn result	return_value(vl.result);}

    /* All arguments apply to the selbri_3 */    process_selbri_3_args(s3, pre, post, lc);  }}/*}}}*/static void process_main_selbri(TreeNode *ms, TermVector *pre, TermVector *post)/*{{{*/{  /* Handle each main selbri after it has been located.  */  TermVector *cpre, *cpost;  XTermVectors *xtv;  TreeNode *s;  LinkConv lc;  type_check(ms, MAIN_SELBRI);  cpre = new(TermVector);  cpost = new(TermVector);  *cpre = *pre;  *cpost = *post;  /* Do we really need to store this property???!!! We do all the     processing on these vectors below! */  xtv = prop_term_vectors(ms, YES);  xtv->pre = cpre;  xtv->post = cpost;  lc_init(&lc);  /*    Roll up the sleeves ..., this is where the real grunge starts.   */  s = child_ref(ms, 0); /* selbri */  process_selbri_args(s, pre, post, &lc);}/*}}}*/

int hash_table_exists(SExp h, SExp key) {	SHash* p;	HashEntry* e;	type_check(h, &TSHash);	p = h.hash;	e = ht_find(&p->ht, key.p);	return e != NULL;}

Value* ExportCalMat_cf(Value** arg_list, int count){		int i = 0;	char* fullpathfilename;	check_arg_count(ExportCalMat, 2, count);	type_check(arg_list[0], String, "[The first argument of ExportCalMat should be a string]");	type_check(arg_list[1], MAXMaterial , "[The 2nd argument of ExportCalMat should be a standard material]");		try	{		fullpathfilename		= arg_list[0]->to_string();		StdMat* stdmat;		if (! strcmp(fullpathfilename,"")) return new Integer(1);		//Get material		Value* val;		val = arg_list[1];		if (! val)return new Integer(2);		if (val->is_kind_of(class_tag(MAXMaterial)) )		{			MtlBase* _mtl;			_mtl = 	val->to_mtlbase();			if (! _mtl)return new Integer(3);			stdmat = static_cast<StdMat*>(_mtl);		}		else		{			return new Integer(3);		}		if ( CMaxMaterialExport::ExportMaterialFromMaxscriptCall(fullpathfilename, stdmat) )			return new Integer(0);				return new Integer(-1);	}	catch(...)	{			//MessageBox(NULL,"Exception catched in ExportCalMat C++ function","Error",MB_OK);		return new Integer(-2);	}}

 tuple& operator=(const obj& o)noexcept(!PY11_ENFORCE) {     if(o.p()!=_p){         type_check(o);         release();         enter(o.p());     }     return *this; }

 set& operator=(const obj& o) {     if(o.p()!=_p){         type_check(o);         release();         enter(o.p());     }     return *this; }

//=============================================================================// subrstatic void s_free_dll_module(SExp s) {	CPtr* p;	HDLL_MODULE hDll;	s = type_check(s, &TString);	p = (CPtr*)S2PTR(s);	hDll = (HDLL_MODULE)p->ptr;	free_dll_module(hDll);	p->ptr = NULL;}

Value*wm3_mc_getname_cf(Value** arg_list, int count){	check_arg_count(wm3_mc_getname, 2, count);	type_check(arg_list[0], MAXModifier, _T("WM3_MC_GetName [Morpher Modifier] [Channel Index]"));	type_check(arg_list[1], Integer, _T("WM3_MC_GetName [Morpher Modifier] [Channel Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	int sel = arg_list[1]->to_int(); sel -= 1;	if(sel>=100) sel = 99;	if(sel<0) sel = 0;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	MaxMorphModifier maxMorpher(mp);	return new String(maxMorpher.GetMorphChannel(sel).GetName());}

Value*wm3_mc_getlimitmin_cf(Value** arg_list, int count){	check_arg_count(wm3_mc_getlimitmin, 2, count);	type_check(arg_list[0], MAXModifier, _T("WM3_MC_GetLimitMIN [Morpher Modifier] [Channel Index]"));	type_check(arg_list[1], Integer, _T("WM3_MC_GetLimitMIN [Morpher Modifier] [Channel Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	int sel = arg_list[1]->to_int(); sel -= 1;	if(sel>=100) sel = 99;	if(sel<0) sel = 0;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	return Float::intern(mp->chanBank[sel].mSpinmin);}

Value*wm3_mc_getnummpts_cf(Value** arg_list, int count){	check_arg_count(wm3_mc_getnummpts, 2, count);	type_check(arg_list[0], MAXModifier, _T("WM3_MC_NumMPts [Morpher Modifier] [Channel Index]"));	type_check(arg_list[1], Integer, _T("WM3_MC_NumMPts [Morpher Modifier] [Channel Index]"));	ReferenceTarget* obj = arg_list[0]->to_modifier();		if( !check_ValidMorpher(obj,arg_list) ) return &false_value;	int sel = arg_list[1]->to_int(); sel -= 1;	if(sel>=100) sel = 99;	if(sel<0) sel = 0;	MorphR3 *mp = (MorphR3*)arg_list[0]->to_modifier();	return Integer::intern(static_cast<int>(mp->chanBank[sel].mPoints.size()));	// SR DCAST64: Downcast to 2G limit.}