Context Navigation

source: dev/BasicCompiler32/Compile_Var.cpp@ 135

Last change on this file since 135 was 135, checked in by dai_9181, 17 years ago
Method/Memberのリファクタリング
File size: 31.9 KB

Rev	Line
[3]	1	#include "../BasicCompiler_Common/common.h"
	2	#include "Opcode.h"
	3
	4	//変数
[76]	5	Variables globalVars;
[3]	6	int AllGlobalVarSize;
	7	int AllInitGlobalVarSize;
[76]	8
[3]	9	int AllLocalVarSize;
	10
[76]	11
[75]	12	void SetRelativeOffset( Type &resultType, RELATIVE_VAR pRelativeVar,const char lpPtrOffset){
[3]	13	PushLongVariable(pRelativeVar);
	14
[75]	15	Type type;
	16	NumOpe( lpPtrOffset, Type(), type );
	17	ChangeTypeToLong( type.GetBasicType() );
[3]	18
	19	//pop ebx
	20	op_pop(REG_EBX);
	21
[75]	22	if( resultType.PtrLevel() ){
	23	resultType.PtrLevelDown();
[63]	24
[75]	25	int typeSize = resultType.GetSize();
	26	if(typeSize>=2){
[64]	27	//imul ebx,i2
[75]	28	op_imul_RV( REG_EBX, typeSize );
[3]	29	}
	30	}
	31	else{
	32	//エラー
	33	SetError(1,NULL,cp);
	34	return;
	35	}
	36
	37	//pop ecx
	38	op_pop(REG_ECX);
	39
	40	//add ecx,ebx
	41	OpBuffer[obp++]=(char)0x03;
	42	OpBuffer[obp++]=(char)0xCB;
	43	}
[64]	44	void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
	45	if(relativeVar.dwKind==VAR_DIRECTMEM){
	46	//mov ecx,dword ptr[ecx]
	47	op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
	48	}
	49	else{
	50	//直接参照に切り替え
	51	SetVarPtrToEax(&relativeVar);
	52	relativeVar.dwKind=VAR_DIRECTMEM;
	53
	54	//mov ecx,dword ptr[eax]
	55	op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
	56	}
	57	}
[75]	58	bool GetArrayOffset(const int SubScripts,char array, const Type &type){
[3]	59	extern HANDLE hHeap;
[75]	60	int i,i2,i3,i4;
[3]	61	char temporary[VN_SIZE],*pParm[MAX_PARMS];
	62
	63	for(i=0,i2=0,i3=0;;i++,i2++){
	64	if(array[i]=='('){
	65	i4=GetStringInPare(temporary+i2,array+i);
	66	i+=i4-1;
	67	i2+=i4-1;
	68	continue;
	69	}
	70	if(array[i]=='['){
	71	i4=GetStringInBracket(temporary+i2,array+i);
	72	i+=i4-1;
	73	i2+=i4-1;
	74	continue;
	75	}
	76	if(array[i]==','\|\|array[i]=='\0'){
	77	if(SubScripts[i3]==-1){
	78	for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
	79	return 0;
	80	}
	81
	82	temporary[i2]=0;
	83
	84	pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
	85	lstrcpy(pParm[i3],temporary);
	86
	87	i3++;
	88
	89	if(array[i]=='\0'){
	90	if(SubScripts[i3]!=-1){
	91	for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
	92	return 0;
	93	}
	94	break;
	95	}
	96
	97	i2=-1;
	98	continue;
	99	}
	100	temporary[i2]=array[i];
	101	}
	102
	103	//push ecx
	104	op_push(REG_ECX);
	105
	106	//push 0
[67]	107	op_push_V(0);
[3]	108
	109	for(i=i3-1;i>=0;i--){
[75]	110	Type tempType;
[3]	111	BOOL bUseHeap;
[75]	112	NumOpe( pParm[i], Type( DEF_LONG ), tempType, &bUseHeap );
	113	if( tempType.IsObject() ){
[3]	114	//キャスト演算子のオーバーロードに対応する
	115	CallCastOperatorProc(
[75]	116	tempType,
	117	bUseHeap, Type(DEF_LONG) );
	118	tempType.SetBasicType( DEF_LONG );
[3]	119	}
[75]	120	ChangeTypeToLong( tempType.GetBasicType() );
[3]	121
	122	//pop eax
	123	op_pop(REG_EAX);
	124
	125	for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;
	126
	127	//imul eax,i4
	128	OpBuffer[obp++]=(char)0x69;
	129	OpBuffer[obp++]=(char)0xC0;
	130	((long )(OpBuffer+obp))=i4;
	131	obp+=sizeof(long);
	132
	133	//add dword ptr[esp],eax
	134	OpBuffer[obp++]=(char)0x01;
	135	OpBuffer[obp++]=(char)0x04;
	136	OpBuffer[obp++]=(char)0x24;
	137
	138	HeapDefaultFree(pParm[i]);
	139	}
	140
	141	//pop eax
	142	op_pop(REG_EAX);
	143
	144	//imul eax,TypeSize
	145	OpBuffer[obp++]=(char)0x69;
	146	OpBuffer[obp++]=(char)0xC0;
[75]	147	((long )(OpBuffer+obp)) = type.GetSize();
[3]	148	obp+=sizeof(long);
	149
	150	//pop ecx
	151	op_pop(REG_ECX);
	152
	153	//add ecx,eax
	154	OpBuffer[obp++]=(char)0x03;
	155	OpBuffer[obp++]=(char)0xC8;
	156
	157	return 1;
	158	}
[75]	159	bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char member, RELATIVE_VAR pRelativeVar, Type &resultType, BOOL bPrivateAccess){
[63]	160	int i;
[3]	161
[75]	162
	163	//////////////////////////////////////
	164	// クラス、配列の構成要素を解析する
	165	//////////////////////////////////////
	166
[3]	167	char VarName[VN_SIZE]; //変数名
	168	char array[VN_SIZE]; //第1次配列
	169	char lpPtrOffset[VN_SIZE]; //第2次配列
	170	char NestMember[VN_SIZE]; //入れ子メンバ
[64]	171	CClass::RefType refType;
[3]	172	lstrcpy(VarName,member);
[75]	173	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
[3]	174
[75]	175
[3]	176	////////////////////////////
	177	// メンバオフセットを取得
	178	////////////////////////////
	179
[75]	180	int offset = objClass.GetMemberOffset( VarName, &i );
	181	if(i==objClass.iMemberNum){
[17]	182	if(isErrorEnabled) SetError(103,VarName,cp);
[75]	183	return false;
[3]	184	}
	185
[75]	186	CMember *pMember=objClass.ppobj_Member[i];
[40]	187
[75]	188
[3]	189	//アクセシビリティをチェック
[75]	190	if(&objClass==pobj_CompilingClass){
[3]	191	//同一クラスオブジェクトの場合はプライベートアクセスを容認する
[40]	192	if(pMember->dwAccess==ACCESS_NON){
[17]	193	if(isErrorEnabled) SetError(107,VarName,cp);
[75]	194	return false;
[3]	195	}
	196	}
	197	else{
[40]	198	if((bPrivateAccess==0&&pMember->dwAccess==ACCESS_PRIVATE)\|\|
	199	pMember->dwAccess==ACCESS_NON){
[17]	200	if(isErrorEnabled) SetError(107,VarName,cp);
[75]	201	return false;
[3]	202	}
[40]	203	else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
[17]	204	if(isErrorEnabled) SetError(108,VarName,cp);
[75]	205	return false;
[3]	206	}
	207	}
	208
[17]	209	//Const定義の場合は書き込みアクセスを制限する
	210	//※コンストラクタをコンパイル中の場合は例外的に許可する
[40]	211	if( pMember->IsConst() && //定数メンバである
[17]	212	isWriteAccess && //書き込みアクセスを要求されている
[75]	213	objClass.IsCompilingConstructor() == false //コンストラクタコンパイル中を除く
[17]	214	){
	215	//Const定義の変数に書き込みアクセスをしようとした場合
	216	SetError(61,VarName,cp);
	217	}
	218
[75]	219	resultType = *pMember;
[3]	220
	221	//ポインタ変数の場合
[75]	222	if( resultType.IsPointer() ){
[40]	223	if(pMember->SubScripts[0]==-1){
[3]	224	lstrcpy(lpPtrOffset,array);
	225	array[0]=0;
	226	}
	227	}
	228	else{
	229	if(lpPtrOffset[0]){
[17]	230	if(isErrorEnabled) SetError(16,member,cp);
[75]	231	return false;
[3]	232	}
	233	}
	234
	235	if(offset){
	236	//add ecx,offset
	237	OpBuffer[obp++]=(char)0x81;
	238	OpBuffer[obp++]=(char)0xC1;
	239	((long )(OpBuffer+obp))=offset;
	240	obp+=sizeof(long);
	241	}
	242
	243	if(array[0]){
	244	//配列オフセット
[75]	245	if(!GetArrayOffset(pMember->SubScripts,array,*pMember)){
[17]	246	if(isErrorEnabled) SetError(14,member,cp);
[75]	247	}
[3]	248	}
[40]	249	else if(pMember->SubScripts[0]!=-1){
[75]	250	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
[3]	251	}
	252
	253	if(NestMember[0]){
	254	//入れ子構造の場合
	255
[75]	256	if( resultType.IsObject() \|\| resultType.IsStruct() ){
[64]	257	if( refType != CClass::Dot ){
[17]	258	if(isErrorEnabled) SetError(104,member,cp);
[75]	259	return false;
[3]	260	}
[64]	261
[75]	262	if( resultType.IsObject() ){
[64]	263	// 参照内容へのポインタを抽出
	264	SetRelativeOffset( *pRelativeVar );
	265	}
[3]	266	}
[75]	267	else if( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() ){
[3]	268	//構造体ポインタ型メンバ変数
	269
	270	if(lpPtrOffset[0]){
	271	//pObj[n].member
[75]	272	if( ( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() )
	273	&& refType != CClass::Dot ){
	274	if(isErrorEnabled) SetError(104,member,cp);
	275	return false;
[3]	276	}
	277
	278	//直接参照に切り替え
[75]	279	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
[3]	280	pRelativeVar->dwKind=VAR_DIRECTMEM;
	281
	282	lpPtrOffset[0]=0;
	283	}
	284	else{
	285	//pObj->member
[75]	286	if( ( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() )
	287	&& refType != CClass::Pointer ){
	288	if(isErrorEnabled) SetError(104,member,cp);
	289	return false;
[3]	290	}
	291
[64]	292	SetRelativeOffset( *pRelativeVar );
[3]	293	}
	294	}
[75]	295	else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2)
	296	\|\| resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){
[3]	297	//構造体ポインタのポインタ型メンバ変数
	298
	299	if(lpPtrOffset[0]){
	300	//ppObj[n]->member
[64]	301	if( refType != CClass::Pointer ){
[17]	302	if(isErrorEnabled) SetError(104,member,cp);
[75]	303	return false;
[3]	304	}
	305
	306	//直接参照に切り替え
[75]	307	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
[3]	308	pRelativeVar->dwKind=VAR_DIRECTMEM;
	309
	310	lpPtrOffset[0]=0;
	311
	312	//mov ecx,dword ptr[ecx]
	313	OpBuffer[obp++]=(char)0x8B;
	314	OpBuffer[obp++]=(char)0x09;
	315	}
	316	else{
[17]	317	if(isErrorEnabled) SetError(104,member,cp);
[75]	318	return false;
[3]	319	}
	320	}
	321
[75]	322	if(!_member_offset(
[17]	323	isErrorEnabled,
	324	isWriteAccess,
[75]	325	pMember->GetClass(),
[3]	326	NestMember,
	327	pRelativeVar,
[75]	328	resultType,
	329	0)) return false;
[3]	330	}
	331
	332	if(lpPtrOffset[0]){
[75]	333	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
[3]	334	pRelativeVar->dwKind=VAR_DIRECTMEM;
	335	}
	336
[75]	337	return true;
[3]	338	}
	339
	340	int LocalVar_ThisPtrOffset;
	341	void SetThisPtrToReg(int reg){
	342	//自身のオブジェクトのThisポインタをregにコピー
	343
	344	RELATIVE_VAR RelativeVar;
	345	RelativeVar.dwKind=VAR_LOCAL;
	346	RelativeVar.bOffsetOffset=0;
	347	RelativeVar.offset=-LocalVar_ThisPtrOffset;
	348
	349	SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
	350	}
	351
[75]	352	bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType,int *pss){
[64]	353	int i;
[106]	354	char variable[VN_SIZE];
[3]	355
	356	if(NameBuffer[0]=='.'){
	357	GetWithName(variable);
	358	lstrcat(variable,NameBuffer);
	359	}
	360	else lstrcpy(variable,NameBuffer);
	361
[106]	362	// 名前空間を分離
	363	char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
	364	Smoothie::Meta::namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName );
	365
	366	// 先頭オブジェクトまたはクラス名と入れ子メンバに分割
[64]	367	CClass::RefType refType;
[106]	368	char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
	369	GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
[49]	370
[106]	371	// 名前空間を分離していた場合は結合
	372	char VarName[VN_SIZE];
	373	if( namespaceStr[0] ){
	374	sprintf( VarName, "%s.%s", namespaceStr, simpleName );
[49]	375	}
[106]	376	else{
	377	lstrcpy( VarName, simpleName );
	378	}
[49]	379
[75]	380	const int *pSubScripts;
	381	bool bConst = false;
[3]	382
[75]	383
	384	if( UserProc::IsLocalAreaCompiling() ){
	385	//////////////////
[3]	386	// ローカル変数
[75]	387	//////////////////
[3]	388
[75]	389	const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName );
	390	if( pVar ){
[3]	391	//ポインタ変数の場合
[75]	392	if( pVar->IsPointer() ){
	393	if( !pVar->IsArray() ){
[3]	394	lstrcpy(lpPtrOffset,array);
	395	array[0]=0;
	396	}
	397	}
	398	else{
	399	if(lpPtrOffset[0]){
	400	SetError(16,variable,cp);
	401	pRelativeVar->dwKind=NON_VAR;
[75]	402	return false;
[3]	403	}
	404	}
	405
[75]	406	pRelativeVar->offset=-pVar->offset;
[3]	407	pRelativeVar->bOffsetOffset=0;
[75]	408	if( pVar->IsRef() ){
	409	// 参照型
	410	pRelativeVar->dwKind = VAR_REFLOCAL;
	411	}
[3]	412	else pRelativeVar->dwKind=VAR_LOCAL;
[75]	413	resultType = *pVar;
	414	pSubScripts=pVar->GetSubScriptsPtr();
	415	bConst = pVar->IsConst();
[3]	416
	417	goto ok;
	418	}
	419	}
	420
	421	if(pobj_CompilingClass){
	422	//////////////////////
	423	// クラスメンバの参照
	424	//////////////////////
	425
	426	if(lstrcmpi(variable,"This")==0){
	427	//Thisオブジェクト
	428
	429	//Thisポインタをecxにコピー
	430	SetThisPtrToReg(REG_ECX);
	431
	432	pRelativeVar->dwKind=VAR_DIRECTMEM;
	433
[75]	434	resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
	435	return true;
[3]	436	}
	437
[76]	438	if(memicmp(variable,"This.",5)==0){
[3]	439	//Thisオブジェクトのメンバを参照するとき
	440	SlideString(variable+5,-5);
	441	lstrcpy(VarName,variable);
	442	}
	443	else{
	444	//クラス内メンバを参照するとき（通常）
	445
	446	for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
[135]	447	if( pobj_CompilingClass->ppobj_Member[i]->GetName() == VarName ){
	448	break;
	449	}
[3]	450	}
	451	if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
	452	}
	453
[18]	454	//Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
	455	//（コンストラクタ、デストラクタ内を除く）
[135]	456	const CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
[18]	457	if( isWriteAccess &&
[135]	458	pMethod->IsConst() &&
[18]	459	pobj_CompilingClass->IsCompilingConstructor() == false &&
	460	pobj_CompilingClass->IsCompilingDestructor() == false
	461	){
	462	SetError(131, NULL, cp );
	463	}
	464
[3]	465	/////////////////////////////
	466	// thisポインタをecxにセット
	467
	468	//Thisポインタをecxにコピー
	469	SetThisPtrToReg(REG_ECX);
	470
	471	pRelativeVar->dwKind=VAR_DIRECTMEM;
[75]	472	if(!_member_offset(
[17]	473	isErrorEnabled,
	474	isWriteAccess,
[75]	475	*pobj_CompilingClass,
[17]	476	variable,
	477	pRelativeVar,
[75]	478	resultType,1)) return false;
	479	return true;
[3]	480	}
	481
	482	NonClassMember:
	483
[75]	484	{
	485	const Variable *pVar;
[3]	486
[75]	487	//////////////////////////
	488	// 静的ローカル変数
	489	// ※"Static.Object.Method.Variable"
	490	//////////////////////////
[3]	491
[75]	492	char temporary[VN_SIZE];
	493	if( UserProc::IsLocalAreaCompiling() ){
	494	GetNowStaticVarFullName(VarName,temporary);
	495
	496	pVar = globalVars.Find( temporary );
	497	if( pVar ){
	498	goto GlobalOk;
	499	}
[3]	500	}
	501
	502
[75]	503	//////////////////////////
	504	// クラスの静的メンバ
	505	//////////////////////////
[3]	506
[75]	507	if(member[0]){
	508	lstrcpy(temporary,member);
[64]	509
[104]	510	// TODO: 名前空間を考慮したコードになっていない
	511
[75]	512	char tempMember[VN_SIZE];
	513	char tempArray[VN_SIZE];
	514	{
	515	CClass::RefType refType;
	516	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
	517	}
[3]	518
[116]	519	int typeDefIndex = Smoothie::Meta::typeDefs.GetIndex( VarName );
	520	if( typeDefIndex != -1 ){
	521	// TypeDef後の型名だったとき
	522	lstrcpy( VarName, Smoothie::Meta::typeDefs[typeDefIndex].GetBaseName().c_str() );
	523	}
	524
[75]	525	char temp2[VN_SIZE];
	526	sprintf(temp2,"%s.%s",VarName,temporary);
	527	pVar = globalVars.Find( temp2 );
	528	if( pVar ){
	529	lstrcpy(member,tempMember);
	530	lstrcpy(array,tempArray);
	531	goto GlobalOk;
	532	}
[3]	533	}
	534
[75]	535	if(pobj_CompilingClass){
	536	//自身のクラスから静的メンバを参照する場合
	537	char temp2[VN_SIZE];
[131]	538	sprintf(temp2,"%s.%s",pobj_CompilingClass->GetName().c_str(),VarName);
[75]	539	pVar = globalVars.Find( temp2 );
	540	if( pVar ){
	541	goto GlobalOk;
	542	}
[3]	543	}
	544
[75]	545	/////////////////////
	546	// グローバル変数
	547	/////////////////////
[3]	548
[75]	549	pVar = globalVars.BackSearch( VarName );
	550	if( pVar ){
[3]	551	goto GlobalOk;
	552	}
	553
[75]	554	if(isErrorEnabled) SetError(3,variable,cp);
	555	pRelativeVar->dwKind=NON_VAR;
	556	return false;
[27]	557
	558
	559
[3]	560	GlobalOk:
[75]	561	//ポインタ変数の場合
	562	if( pVar->IsPointer() ){
	563	if( !pVar->IsArray() ){
	564	lstrcpy(lpPtrOffset,array);
	565	array[0]=0;
	566	}
[3]	567	}
[75]	568	else{
	569	if(lpPtrOffset[0]){
	570	SetError(16,variable,cp);
	571	pRelativeVar->dwKind=NON_VAR;
	572	return false;
	573	}
[3]	574	}
	575
[75]	576	pRelativeVar->offset=pVar->offset;
	577	pRelativeVar->bOffsetOffset=0;
	578	if( pVar->IsRef() ){
	579	// 参照型
	580	pRelativeVar->dwKind = VAR_REFGLOBAL;
	581	}
	582	else pRelativeVar->dwKind=VAR_GLOBAL;
	583	resultType = *pVar;
	584	pSubScripts=pVar->GetSubScriptsPtr();
	585	bConst = pVar->IsConst();
[62]	586	}
[3]	587
	588
[75]	589
[3]	590	ok:
	591
[18]	592	if( bConst && isWriteAccess ){
[11]	593	//Const定義の変数に書き込みアクセスをしようとした場合
[75]	594	if( resultType.IsObject() ){
[18]	595	//オブジェクト定数
	596	SetError(130, VarName, cp );
	597	}
	598	else{
	599	//一般のConst変数
	600	SetError(61,VarName,cp);
	601	}
[11]	602	}
[3]	603
	604	if(array[0]==0&&pSubScripts[0]!=-1){
	605	//配列の先頭ポインタを示す場合
[75]	606	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
[3]	607	if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
[75]	608	return true;
[3]	609	}
	610
	611	if(array[0]\|\|member[0]){
	612	//xor ecx,ecx（ecxを0に初期化する）
	613	//※ecxは変数ベースアドレスからの相対オフセットを示す
	614	op_zero_reg(REG_ECX);
	615
	616	pRelativeVar->bOffsetOffset=1;
	617	}
	618	if(array[0]){
[75]	619	if(!GetArrayOffset(pSubScripts,array,resultType)){
[3]	620	SetError(14,variable,cp);
	621	pRelativeVar->dwKind=NON_VAR;
[75]	622	return false;
[3]	623	}
	624	}
	625	if(member[0]){
[75]	626	if( resultType.IsObject() \|\| resultType.IsStruct() ){
[3]	627	//実態オブジェクトのメンバを参照（obj.member）
[64]	628	if( refType != CClass::Dot ){
[3]	629	SetError(104,VarName,cp);
	630	pRelativeVar->dwKind=NON_VAR;
[75]	631	return false;
[3]	632	}
[64]	633
[75]	634	if( resultType.IsObject() ){
[64]	635	// 参照内容へのポインタを抽出
	636	SetRelativeOffset( *pRelativeVar );
	637	}
[3]	638	}
[75]	639	else if( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() ){
[3]	640	//ポインタオブジェクトが示すメンバを参照
	641	if(lpPtrOffset[0]){
	642	//pObj[n].member
[64]	643	if( refType != CClass::Dot ){
[3]	644	SetError(104,VarName,cp);
	645	pRelativeVar->dwKind=NON_VAR;
[75]	646	return false;
[3]	647	}
[75]	648	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
[3]	649	pRelativeVar->dwKind=VAR_DIRECTMEM;
	650	}
	651	else{
	652	//pObj->member
[64]	653	if( refType != CClass::Pointer ){
[3]	654	SetError(104,VarName,cp);
	655	pRelativeVar->dwKind=NON_VAR;
[75]	656	return false;
[3]	657	}
	658
	659	SetVarPtrToEax(pRelativeVar);
	660	pRelativeVar->dwKind=VAR_DIRECTMEM;
	661
	662	//mov ecx,dword ptr[eax]
	663	OpBuffer[obp++]=(char)0x8B;
	664	OpBuffer[obp++]=(char)0x08;
	665	}
	666	}
[75]	667	else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) \|\| resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){
[3]	668	//ポインタオブジェクトが示すメンバを参照
	669	if(lpPtrOffset[0]){
	670	//ppObj[n]->member
[64]	671	if( refType != CClass::Pointer ){
[3]	672	SetError(104,VarName,cp);
	673	pRelativeVar->dwKind=NON_VAR;
[75]	674	return false;
[3]	675	}
	676
[75]	677	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
[3]	678	pRelativeVar->dwKind=VAR_DIRECTMEM;
	679
	680
	681	SetVarPtrToEax(pRelativeVar);
	682
	683	//mov ecx,dword ptr[eax]
	684	OpBuffer[obp++]=(char)0x8B;
	685	OpBuffer[obp++]=(char)0x08;
	686	}
	687	else{
	688	SetError(104,VarName,cp);
	689	pRelativeVar->dwKind=NON_VAR;
[75]	690	return false;
[3]	691	}
	692	}
	693	else{
	694	SetError(102,VarName,cp);
	695	pRelativeVar->dwKind=NON_VAR;
[75]	696	return false;
[3]	697	}
[17]	698
[75]	699	if(!_member_offset(
[17]	700	isErrorEnabled,
	701	isWriteAccess,
[75]	702	resultType.GetClass(),
	703	member,pRelativeVar,resultType,0)) return false;
[17]	704
[75]	705	return true;
[3]	706	}
	707
	708	if(lpPtrOffset[0]){
[75]	709	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
[3]	710	pRelativeVar->dwKind=VAR_DIRECTMEM;
	711	}
	712
[75]	713	return true;
[3]	714	}
	715
[75]	716	bool SetInitGlobalData(int offset,const Type &type,const int SubScripts,char InitBuf){
[3]	717	extern BYTE *initGlobalBuf;
[75]	718	int i,i2,i3;
[3]	719	char temporary[VN_SIZE];
	720
	721	if(InitBuf[0]=='['){
	722	SlideString(InitBuf+1,-1);
	723	InitBuf[lstrlen(InitBuf)-1]=0;
	724
[75]	725	int typeSize = type.GetSize();
[3]	726
	727	if(SubScripts[0]!=-1){
[75]	728	typeSize*=JumpSubScripts(SubScripts+1);
[3]	729	i=0;
	730	i2=0;
	731	while(1){
	732	if(SubScripts[0]<i2){
	733	SetError(41,0,cp);
	734	return 0;
	735	}
	736	i=GetOneParameter(InitBuf,i,temporary);
	737	if(!SetInitGlobalData(
[75]	738	offset+i2*typeSize,
[3]	739	type,
	740	SubScripts+1,
[75]	741	temporary)) return false;
[3]	742	i2++;
	743	if(InitBuf[i]=='\0') break;
	744	}
[75]	745	return true;
[3]	746	}
	747
[75]	748	if(type.IsStruct()){
	749	const CClass &objClass = type.GetClass();
[3]	750
[75]	751	for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
[3]	752	i=GetOneParameter(InitBuf,i,temporary);
	753
[135]	754	i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->GetName().c_str(), NULL );
[3]	755
	756	if(!SetInitGlobalData(offset+i3,
[75]	757	*objClass.ppobj_Member[i2],
	758	objClass.ppobj_Member[i2]->SubScripts,
	759	temporary)) return false;
[3]	760
	761	if(InitBuf[i]=='\0') break;
	762	}
[75]	763	if(i2+1!=objClass.iMemberNum){
[3]	764	SetError(41,0,cp);
[75]	765	return false;
[3]	766	}
[75]	767	return true;
[3]	768	}
	769
	770	SetError(41,0,cp);
[75]	771	return false;
[3]	772	}
	773
[20]	774
	775	///////////////////////////////////////
	776	// 単発式（[]で囲まれていない）
	777	///////////////////////////////////////
	778
[75]	779	if( type.IsObject() \|\| type.IsStruct() ){
[64]	780	//オブジェクトまたは構造体の場合はありえない
[20]	781	SetError(300,NULL,cp);
[75]	782	return false;
[20]	783	}
	784
[3]	785	if(SubScripts[0]!=-1){
	786	SetError(41,0,cp);
[75]	787	return false;
[3]	788	}
	789
	790	double dbl;
	791	_int64 i64data;
[75]	792	Type calcType;
	793
	794	if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
	795	//動的データだった場合
	796	return false;
	797	}
	798	if( calcType.IsReal() ){
[3]	799	memcpy(&dbl,&i64data,sizeof(double));
	800	i64data=(_int64)dbl;
	801	}
	802	else dbl=(double)i64data;
	803
	804	//型チェック
	805	CheckDifferentType(
	806	type,
[75]	807	calcType,
[3]	808	0,0);
	809
[75]	810	if( type.IsDouble() ){
[3]	811	(double )(initGlobalBuf+offset)=(double)dbl;
[75]	812	}
	813	else if( type.IsSingle() ){
[3]	814	(float )(initGlobalBuf+offset)=(float)dbl;
[75]	815	}
	816	else if( type.Is64() ){
[3]	817	(_int64 )(initGlobalBuf+offset)=i64data;
[75]	818	}
	819	else if( type.IsLong() \|\| type.IsDWord() \|\| type.IsPointer() ){
[97]	820	if(type.GetBasicType()==typeOfPtrChar){
[3]	821	//文字列定数のとき
	822
	823	char *temp;
	824	temp=(char *)i64data;
[56]	825	i2=dataTable.AddString(temp,lstrlen(temp));
[3]	826	HeapDefaultFree(temp);
	827
	828	//mov eax,DataPos
	829	OpBuffer[obp++]=(char)0xB8;
	830	((long )(OpBuffer+obp))=(long)i2;
	831	pobj_DataTableSchedule->add();
	832	obp+=sizeof(long);
	833
	834	//mov dword ptr[offset],eax
	835	OpBuffer[obp++]=(char)0xA3;
	836	((long )(OpBuffer+obp))=offset;
	837	pobj_GlobalVarSchedule->add();
	838	obp+=sizeof(long);
	839	}
	840	else{
	841	(DWORD )(initGlobalBuf+offset)=(DWORD)i64data;
	842	}
	843	}
[75]	844	else if( type.IsWord() \|\| type.IsInteger() ){
[3]	845	(WORD )(initGlobalBuf+offset)=(WORD)i64data;
[75]	846	}
	847	else if( type.IsSByte() \|\| type.IsByte() \|\| type.IsBoolean() ){
[3]	848	(BYTE )(initGlobalBuf+offset)=(BYTE)i64data;
[75]	849	}
	850
	851	return true;
[3]	852	}
[75]	853	bool InitLocalVar(int offset,const Type &type,const int SubScripts,char InitBuf){
	854	int i,i2,i3;
[3]	855	char temporary[VN_SIZE];
	856
	857	if(InitBuf[0]=='['){
	858	SlideString(InitBuf+1,-1);
	859	InitBuf[lstrlen(InitBuf)-1]=0;
	860
[75]	861	int typeSize = type.GetSize();
[3]	862
	863	if(SubScripts[0]!=-1){
[75]	864	typeSize*=JumpSubScripts(SubScripts+1);
[3]	865	i=0;
	866	i2=0;
	867	while(1){
	868	if(SubScripts[0]<i2){
	869	SetError(41,0,cp);
[75]	870	return false;
[3]	871	}
	872	i=GetOneParameter(InitBuf,i,temporary);
	873	if(!InitLocalVar(
[75]	874	offset+i2*typeSize,
[3]	875	type,
	876	SubScripts+1,
[75]	877	temporary)) return false;
[3]	878	i2++;
	879	if(InitBuf[i]=='\0') break;
	880	}
[75]	881	return true;
[3]	882	}
	883
[75]	884	if(type.IsStruct()){
	885	const CClass &objClass = type.GetClass();
[3]	886
[75]	887	for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
[3]	888	i=GetOneParameter(InitBuf,i,temporary);
	889
[135]	890	i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->GetName().c_str(), NULL );
[3]	891
	892	if(!InitLocalVar(offset+i3,
[75]	893	*objClass.ppobj_Member[i2],
	894	objClass.ppobj_Member[i2]->SubScripts,
	895	temporary)) return false;
[3]	896
	897	if(InitBuf[i]=='\0') break;
	898	}
[75]	899	if(i2+1!=objClass.iMemberNum){
[3]	900	SetError(41,0,cp);
	901	return 0;
	902	}
[75]	903	return true;
[3]	904	}
	905
	906	SetError(41,0,cp);
[75]	907	return false;
[3]	908	}
	909
[20]	910
	911	///////////////////////////////////////
	912	// 単発式（[]で囲まれていない）
	913	///////////////////////////////////////
	914
[3]	915	if(SubScripts[0]!=-1){
	916	SetError(41,0,cp);
[75]	917	return false;
[3]	918	}
	919
	920	double dbl;
	921	_int64 i64data;
[75]	922	Type calcType;
	923
	924	if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
[8]	925	//動的データだった場合
[75]	926	return false;
[8]	927	}
[75]	928	if( calcType.IsReal() ){
[3]	929	memcpy(&dbl,&i64data,sizeof(double));
	930	i64data=(_int64)dbl;
	931	}
	932	else dbl=(double)i64data;
	933
	934	//型チェック
	935	CheckDifferentType(
	936	type,
[75]	937	calcType,
[3]	938	0,0);
	939
[75]	940	if( type.IsDouble() ){
[3]	941	//mov eax,HILONG(dbl)
	942	OpBuffer[obp++]=(char)0xB8;
	943	((long )(OpBuffer+obp))=(long)(long )(((char *)(&dbl))+4);
	944	obp+=sizeof(long);
	945
	946	//mov dword ptr[ebp+offset+sizeof(long)],eax
	947	OpBuffer[obp++]=(char)0x89;
	948	OpBuffer[obp++]=(char)0x85;
	949	((long )(OpBuffer+obp))=offset+sizeof(long);
	950	AddLocalVarAddrSchedule();
	951	obp+=sizeof(long);
	952
	953	//mov eax,LOLONG(dbl)
	954	OpBuffer[obp++]=(char)0xB8;
	955	((long )(OpBuffer+obp))=(long )(&dbl);
	956	obp+=sizeof(long);
	957
	958	//mov dword ptr[ebp+offset],eax
	959	OpBuffer[obp++]=(char)0x89;
	960	OpBuffer[obp++]=(char)0x85;
	961	((long )(OpBuffer+obp))=offset;
	962	AddLocalVarAddrSchedule();
	963	obp+=sizeof(long);
	964	}
[75]	965	else if( type.IsSingle() ){
[3]	966	float flt;
	967	flt=(float)dbl;
	968	//mov eax,InitValue
	969	OpBuffer[obp++]=(char)0xB8;
	970	((long )(OpBuffer+obp))=(long )&flt;
	971	obp+=sizeof(long);
	972
	973	//mov dword ptr[ebp+offset],eax
	974	OpBuffer[obp++]=(char)0x89;
	975	OpBuffer[obp++]=(char)0x85;
	976	((long )(OpBuffer+obp))=offset;
	977	AddLocalVarAddrSchedule();
	978	obp+=sizeof(long);
	979	}
[75]	980	else if( type.Is64() ){
[3]	981	//mov eax,HILONG(i64data)
	982	OpBuffer[obp++]=(char)0xB8;
	983	((long )(OpBuffer+obp))=(long)(long )(((char *)(&i64data))+4);
	984	obp+=sizeof(long);
	985
	986	//mov dword ptr[ebp+offset+sizeof(long)],eax
	987	OpBuffer[obp++]=(char)0x89;
	988	OpBuffer[obp++]=(char)0x85;
	989	((long )(OpBuffer+obp))=offset+sizeof(long);
	990	AddLocalVarAddrSchedule();
	991	obp+=sizeof(long);
	992
	993	//mov eax,LOLONG(i64data)
	994	OpBuffer[obp++]=(char)0xB8;
	995	((long )(OpBuffer+obp))=(long )(&i64data);
	996	obp+=sizeof(long);
	997
	998	//mov dword ptr[ebp+offset],eax
	999	OpBuffer[obp++]=(char)0x89;
	1000	OpBuffer[obp++]=(char)0x85;
	1001	((long )(OpBuffer+obp))=offset;
	1002	AddLocalVarAddrSchedule();
	1003	obp+=sizeof(long);
	1004	}
[75]	1005	else if( type.IsDWord() \|\| type.IsLong() \|\| type.IsPointer() ){
[97]	1006	if(type.GetBasicType()==typeOfPtrChar){
[3]	1007	//文字列定数のとき
	1008
	1009	char *temp;
	1010	temp=(char *)i64data;
[56]	1011	i2=dataTable.AddString(temp,lstrlen(temp));
[3]	1012	HeapDefaultFree(temp);
	1013
	1014	//mov eax,DataPos
	1015	OpBuffer[obp++]=(char)0xB8;
	1016	((long )(OpBuffer+obp))=(long)i2;
	1017	pobj_DataTableSchedule->add();
	1018	obp+=sizeof(long);
	1019	}
	1020	else{
	1021	//mov eax,InitValue
	1022	OpBuffer[obp++]=(char)0xB8;
	1023	((long )(OpBuffer+obp))=(long)i64data;
	1024	obp+=sizeof(long);
	1025	}
	1026
	1027	//mov dword ptr[ebp+offset],eax
	1028	OpBuffer[obp++]=(char)0x89;
	1029	OpBuffer[obp++]=(char)0x85;
	1030	((long )(OpBuffer+obp))=offset;
	1031	AddLocalVarAddrSchedule();
	1032	obp+=sizeof(long);
	1033	}
[75]	1034	else if( type.IsWord() \|\| type.IsInteger() ){
[3]	1035	//mov ax,InitValue
	1036	OpBuffer[obp++]=(char)0x66;
	1037	OpBuffer[obp++]=(char)0xB8;
	1038	((WORD )(OpBuffer+obp))=(WORD)i64data;
	1039	obp+=sizeof(WORD);
	1040
	1041	//mov word ptr[ebp+offset],ax
	1042	OpBuffer[obp++]=(char)0x66;
	1043	OpBuffer[obp++]=(char)0x89;
	1044	OpBuffer[obp++]=(char)0x85;
	1045	((long )(OpBuffer+obp))=offset;
	1046	AddLocalVarAddrSchedule();
	1047	obp+=sizeof(long);
	1048	}
[75]	1049	else if( type.IsSByte() \|\| type.IsByte() \|\| type.IsBoolean() ){
[3]	1050	//mov byte ptr[ebp+offset],InitValue
	1051	OpBuffer[obp++]=(char)0xC6;
	1052	OpBuffer[obp++]=(char)0x85;
	1053	((long )(OpBuffer+obp))=offset;
	1054	AddLocalVarAddrSchedule();
	1055	obp+=sizeof(long);
	1056	((BYTE )(OpBuffer+obp))=(BYTE)i64data;
	1057	obp+=sizeof(BYTE);
	1058	}
[75]	1059
	1060	return true;
[3]	1061	}
	1062
[79]	1063	void dim( char VarName,int SubScripts,Type &type,char InitBuf,char ConstractParameter,DWORD dwFlags){
[75]	1064	if( UserProc::IsGlobalAreaCompiling() ){
[64]	1065	/////////////////////////
	1066	// グローバル変数
	1067	/////////////////////////
	1068
[79]	1069	AddGlobalVariable(VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags);
[64]	1070	}
	1071	else{
	1072	/////////////////
	1073	// ローカル変数
	1074	/////////////////
	1075
[79]	1076	if( UserProc::CompilingUserProc().localVars.DuplicateCheck( VarName ) ){
[75]	1077	//２重定義のエラー
	1078	SetError(15,VarName,cp);
	1079	return;
[64]	1080	}
	1081
[75]	1082	bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
[64]	1083
[79]	1084	Variable *pVar = new Variable( VarName, type, isConst );
[75]	1085
	1086	if( SubScripts[0] != -1 ){
	1087	//配列あり
	1088	pVar->SetArray( SubScripts );
[64]	1089	}
	1090
[75]	1091	//コンストラクタ用パラメータ
	1092	pVar->paramStrForConstructor = ConstractParameter;
[64]	1093
[75]	1094	//レキシカルスコープ
	1095	pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
	1096	pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
	1097	pVar->bLiving=TRUE;
	1098
	1099	//エラー用
	1100	pVar->source_code_address=cp;
	1101
	1102	// 変数を追加
	1103	UserProc::CompilingUserProc().localVars.push_back( pVar );
	1104
	1105	//アラインメントを考慮
	1106	if( pVar->IsStruct() ){
	1107	int alignment = pVar->GetClass().iAlign;
[120]	1108
[75]	1109	if( alignment ){
	1110	if( AllLocalVarSize % alignment ){
	1111	AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
	1112	}
	1113	}
[120]	1114
	1115	if( alignment == PTR_SIZE*2 ){
	1116	// ポインタに要するサイズよりも一回り大きなアラインメントが指定されているとき
	1117	// （例:CONTEXT構造体など）
	1118	// 呼び出し側のオフセットズレを考慮する
	1119
	1120	if( 0 == ( UserProc::CompilingUserProc().RealParams().GetMemorySize() + PTR_SIZE/ret分/ ) % alignment ){
	1121	AllLocalVarSize += PTR_SIZE;
	1122	}
	1123	}
[64]	1124	}
	1125
[75]	1126	AllLocalVarSize += pVar->GetMemorySize();
	1127	pVar->offset = AllLocalVarSize;
[64]	1128
	1129	//レキシカルスコープ
	1130	pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
	1131	pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
	1132	pVar->bLiving=TRUE;
	1133
	1134	if(InitBuf[0]){
	1135	//初期代入時のみ、書き込みアクセスを許可する
[75]	1136	if( isConst ){
	1137	pVar->ConstOff();
	1138	}
[64]	1139
	1140	int result = 0;
[75]	1141	if( !pVar->IsObject() ){
[64]	1142	result = InitLocalVar(-pVar->offset,
[75]	1143	*pVar,
	1144	pVar->GetSubScriptsPtr(),
[64]	1145	InitBuf);
	1146	}
	1147
	1148	if(!result){
	1149	//動的な式だった場合は代入演算を行う
	1150	char temporary[8192];
	1151	sprintf(temporary,"%s=%s",VarName,InitBuf);
	1152	OpcodeCalc(temporary);
	1153	}
	1154
[75]	1155	if( isConst ){
	1156	pVar->ConstOn();
	1157	}
[64]	1158	}
	1159	else{
	1160	//push 0
[67]	1161	op_push_V(0);
[64]	1162
	1163	//push VarSize
[75]	1164	op_push_V( pVar->GetMemorySize() );
[64]	1165
	1166	//mov eax,ebp
	1167	OpBuffer[obp++]=(char)0x8B;
	1168	OpBuffer[obp++]=(char)0xC5;
	1169
	1170	//add eax,offset
	1171	OpBuffer[obp++]=(char)0x05;
	1172	((long )(OpBuffer+obp))=-pVar->offset;
	1173	AddLocalVarAddrSchedule();
	1174	obp+=sizeof(long);
	1175
	1176	//push eax
	1177	op_push(REG_EAX);
	1178
	1179	//call FillMemory
	1180	OpBuffer[obp++]=(char)0xFF;
	1181	OpBuffer[obp++]=(char)0x15;
[75]	1182	DllProc *pDllProc = GetDeclareHash("FillMemory");
	1183	pDllProc->Using();
	1184	pobj_ImportAddrSchedule->add(pDllProc);
[64]	1185	obp+=sizeof(long);
	1186	}
	1187	}
	1188
	1189	//New呼び出し
[75]	1190	if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
[64]	1191	char objectSize[255];
	1192	if( SubScripts[0] == -1 ){
	1193	objectSize[0] = 0;
	1194	}
	1195	else{
	1196	if( SubScripts[1] != -1 ){
	1197	SetError(300,NULL,cp);
	1198	}
	1199	sprintf( objectSize, "%d", SubScripts[0] );
	1200	}
[75]	1201	Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
[64]	1202
	1203	//pop eax
	1204	op_pop( REG_EAX );
	1205
	1206	RELATIVE_VAR RelativeVar;
[75]	1207	GetVarOffset( true, false, VarName, &RelativeVar, Type() );
[64]	1208	if( RelativeVar.dwKind == VAR_DIRECTMEM ){
	1209	SetError();
	1210	}
	1211	SetVariableFromEax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
	1212	}
	1213	}
[3]	1214
	1215	void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar){
	1216	if(pRelativeVar->dwKind==VAR_GLOBAL){
	1217	if(pRelativeVar->bOffsetOffset){
	1218	//lea eax,dword ptr[ecx+offset]
	1219	OpBuffer[obp++]=(char)0x8D;
	1220	OpBuffer[obp++]=(char)0x81;
	1221	((long )(OpBuffer+obp))=pRelativeVar->offset;
	1222	pobj_GlobalVarSchedule->add();
	1223	obp+=sizeof(long);
	1224	}
	1225	else{
	1226	//mov eax,offset
	1227	OpBuffer[obp++]=(char)0xB8;
	1228	((long )(OpBuffer+obp))=pRelativeVar->offset;
	1229	pobj_GlobalVarSchedule->add();
	1230	obp+=sizeof(long);
	1231	}
	1232	}
[62]	1233	else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
	1234	if(pRelativeVar->bOffsetOffset){
	1235	//mov eax,ecx
	1236	OpBuffer[obp++]=(char)0x8B;
	1237	OpBuffer[obp++]=(char)0xC1;
	1238
	1239	//add eax,dword ptr[offset]
	1240	op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
	1241	}
	1242	else{
	1243	//mov eax,dword ptr[offset]
	1244	op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
	1245	}
	1246	obp-=sizeof(long);
	1247	pobj_GlobalVarSchedule->add();
	1248	obp+=sizeof(long);
	1249	}
[3]	1250	else if(pRelativeVar->dwKind==VAR_LOCAL){
	1251	if(pRelativeVar->bOffsetOffset){
	1252	//add ecx,offset
	1253	OpBuffer[obp++]=(char)0x81;
	1254	OpBuffer[obp++]=(char)0xC1;
	1255	((long )(OpBuffer+obp))=pRelativeVar->offset;
	1256	AddLocalVarAddrSchedule();
	1257	obp+=sizeof(long);
	1258
	1259	//lea eax,dword ptr[ebp+ecx]
	1260	OpBuffer[obp++]=(char)0x8D;
	1261	OpBuffer[obp++]=(char)0x44;
	1262	OpBuffer[obp++]=(char)0x0D;
	1263	OpBuffer[obp++]=(char)0x00;
	1264	}
	1265	else{
	1266	//lea eax,dword ptr[ebp+offset]
	1267	OpBuffer[obp++]=(char)0x8D;
	1268	OpBuffer[obp++]=(char)0x85;
	1269	((long )(OpBuffer+obp))=pRelativeVar->offset;
	1270	AddLocalVarAddrSchedule();
	1271	obp+=sizeof(long);
	1272	}
	1273	}
	1274	else if(pRelativeVar->dwKind==VAR_REFLOCAL){
	1275	if(pRelativeVar->bOffsetOffset){
	1276	//mov eax,ecx
	1277	OpBuffer[obp++]=(char)0x8B;
	1278	OpBuffer[obp++]=(char)0xC1;
	1279
	1280	//add eax,dword ptr[ebp+offset]
	1281	OpBuffer[obp++]=(char)0x03;
	1282	OpBuffer[obp++]=(char)0x85;
	1283	((long )(OpBuffer+obp))=pRelativeVar->offset;
	1284	AddLocalVarAddrSchedule();
	1285	obp+=sizeof(long);
	1286	}
	1287	else{
	1288	//mov eax,dword ptr[ebp+offset]
	1289	OpBuffer[obp++]=(char)0x8B;
	1290	OpBuffer[obp++]=(char)0x85;
	1291	((long )(OpBuffer+obp))=pRelativeVar->offset;
	1292	AddLocalVarAddrSchedule();
	1293	obp+=sizeof(long);
	1294	}
	1295	}
	1296	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
	1297	//mov eax,ecx
	1298	OpBuffer[obp++]=(char)0x8B;
	1299	OpBuffer[obp++]=(char)0xC1;
	1300	}
	1301	}
[97]	1302	void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
	1303	if( reg != REG_EAX ){
	1304	SetError();
	1305	//TODO: 未完成
	1306	}
	1307	SetVarPtrToEax( pRelativeVar );
	1308	}
[95]	1309
	1310	bool Compile_AddGlobalRootsForGc(){
	1311	UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
	1312	if( !pUserProc_AddGlobalRootPtr ){
	1313	SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
	1314	return false;
	1315	}
	1316
	1317	BOOST_FOREACH( const Variable *pVar, globalVars ){
	1318	if( pVar->IsObject() \|\| pVar->IsPointer() \|\| pVar->IsStruct() ){
	1319	// オブジェクトまたはポインタだったとき
	1320	// ※構造体も含む（暫定対応）
	1321
	1322	// 変数領域に要するLONG_PTR単位の個数を引き渡す
	1323	op_push_V( pVar->GetMemorySize()/PTR_SIZE );
	1324
	1325
	1326	/////////////////////////////
	1327	// ルートポインタを引き渡す
	1328
	1329	//mov eax,offset
	1330	op_mov_RV(REG_EAX,(int)pVar->offset);
	1331	obp-=sizeof(long);
	1332	pobj_GlobalVarSchedule->add();
	1333	obp+=sizeof(long);
	1334
	1335	//push eax
	1336	op_push( REG_EAX );
	1337
	1338	//
	1339	/////////////////////////////
	1340
	1341
	1342	/////////////////////////////
	1343	// Thisポインタを引き渡す
	1344
	1345	SetThisPtrToReg(REG_EAX);
	1346
	1347	//push eax
	1348	op_push( REG_EAX );
	1349
	1350	//
	1351	/////////////////////////////
	1352
	1353
	1354	// call AddGlobalRootPtr
	1355	op_call( pUserProc_AddGlobalRootPtr );
	1356
	1357	ReallocNativeCodeBuffer();
	1358	}
	1359	}
	1360
	1361	return true;
	1362	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: