#include "../BasicCompiler_Common/common.h"
#include "Opcode.h"

//変数
VARIABLE *GlobalVar;
int MaxGlobalVarNum;
int AllGlobalVarSize;
int AllInitGlobalVarSize;
VARIABLE *LocalVar;
int MaxLocalVarNum;
int AllLocalVarSize;


void SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
	int i2;


	/////////////////////////////////////////////
	// 先頭ポインタをr12に取得してメモリへ退避
	/////////////////////////////////////////////

	SetReg_WholeVariable(DEF_INT64,pRelativeVar,REG_R11);

	//mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
	pobj_sf->push(REG_R11);


	////////////////////////////////
	// 添え字を計算する
	////////////////////////////////

	int reg=REG_NON;
	i2=NumOpe(&reg,lpPtrOffset,0,0,0);
	if(!IsWholeNumberType(i2)) SetError(46,NULL,cp);
	ExtendTypeTo64(i2,reg);

	if(reg==REG_R14){
		//mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
		pobj_sf->pop(REG_R14);
	}

	if(PTR_LEVEL(*pType)){
		*pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
		if((*pType)==DEF_OBJECT){
			//imul reg,objsize
			op_imul_value(sizeof(_int64),reg,GetSizeOfClassMember((CClass *)lpIndex,NULL,NULL));
		}
		else{
			i2=GetTypeSize(*pType,-1);
			if(i2>=2){
				//imul reg,i2
				op_imul_value(sizeof(_int64),reg,i2);
			}
		}
	}
	else{
		//エラー
		SetError(1,NULL,cp);
		return;
	}


	//////////////////////////////
	// 先頭ポインタに添え字を加算
	//////////////////////////////

	//mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
	pobj_sf->pop(REG_R11);

	//add r11,reg
	op_add64_reg(REG_R11,reg);
}
BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
	extern HANDLE hHeap;
	int i,i2,i3,i4,TypeSize;
	char temporary[VN_SIZE],*pParm[MAX_PARMS];

	for(i=0,i2=0,i3=0;;i++,i2++){
		if(array[i]=='('){
			i4=GetStringInPare(temporary+i2,array+i);
			i+=i4-1;
			i2+=i4-1;
			continue;
		}
		if(array[i]=='['){
			i4=GetStringInBracket(temporary+i2,array+i);
			i+=i4-1;
			i2+=i4-1;
			continue;
		}
		if(array[i]==','||array[i]=='\0'){
			if(SubScripts[i3]==-1){
				for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
				return 0;
			}

			temporary[i2]=0;

			pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
			lstrcpy(pParm[i3],temporary);

			i3++;

			if(array[i]=='\0'){
				if(SubScripts[i3]!=-1){
					for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
					return 0;
				}
				break;
			}

			i2=-1;
			continue;
		}
		temporary[i2]=array[i];
	}

	//mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
	pobj_sf->push(REG_R11);

	//xor r12,r12
	op_zero_reg(REG_R12);

	for(i=i3-1;i>=0;i--){
		//mov qword ptr[rsp+offset],r12     ※スタックフレームを利用
		pobj_sf->push(REG_R12);

		int reg=REG_NON;
		TYPEINFO TypeInfo;
		BOOL bUseHeap;
		TypeInfo.type=NumOpe(&reg,pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
		if(TypeInfo.type==DEF_OBJECT){
			//キャスト演算子のオーバーロードに対応する
			CallCastOperatorProc(reg,
				TypeInfo.type,TypeInfo.u.lpIndex,
				bUseHeap,DEF_LONG,-1);
			TypeInfo.type=DEF_LONG;
		}

		if(!IsWholeNumberType(TypeInfo.type)) SetError(46,NULL,cp);
		ExtendTypeTo64(TypeInfo.type,reg);

		if(reg==REG_R14){
			//mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
			pobj_sf->pop(REG_R14);
		}

		//mov r12,qword ptr[rsp+offset]     ※スタックフレームを利用
		pobj_sf->pop(REG_R12);

		for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;

		//imul reg,i4
		op_imul_value(sizeof(_int64),reg,i4);

		//add r12,reg
		op_add64_reg(REG_R12,reg);

		HeapDefaultFree(pParm[i]);
	}

	TypeSize=GetTypeSize(type,lpIndex);

	//imul r12,TypeSize
	OpBuffer[obp++]=(char)0x4D;
	OpBuffer[obp++]=(char)0x69;
	OpBuffer[obp++]=(char)0xE4;
	*((long *)(OpBuffer+obp))=TypeSize;
	obp+=sizeof(long);

	//mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
	pobj_sf->pop(REG_R11);

	//add r11,r12
	OpBuffer[obp++]=(char)0x4D;
	OpBuffer[obp++]=(char)0x03;
	OpBuffer[obp++]=(char)0xDC;

	return 1;
}
BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass *pobj_c, char *member, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
	int i,offset;


	//////////////////////////////////////
	// クラス、配列の構成要素を解析する
	//////////////////////////////////////

	char VarName[VN_SIZE];		//変数名
	char array[VN_SIZE];		//第1次配列
	char lpPtrOffset[VN_SIZE];	//第2次配列
	char NestMember[VN_SIZE];	//入れ子メンバ
	int RefType;				//"."参照のときは0、"->"参照のときは1
	lstrcpy(VarName,member);
	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;


	////////////////////////////
	// メンバオフセットを取得
	////////////////////////////

	offset=GetSizeOfClassMember(pobj_c,VarName,&i);
	if(i==pobj_c->iMemberNum){
		if(isErrorEnabled) SetError(103,VarName,cp);
		return 0;
	}

	CMember *pMember=pobj_c->ppobj_Member[i];


	//アクセシビリティをチェック
	if(pobj_c==pobj_CompilingClass){
		//同一クラスオブジェクトの場合はプライベートアクセスを容認する
		if(pMember->dwAccess==ACCESS_NON){
			if(isErrorEnabled) SetError(107,VarName,cp);
			return 0;
		}
	}
	else{
		if((bPrivateAccess==0&&pMember->dwAccess==ACCESS_PRIVATE)||
			pMember->dwAccess==ACCESS_NON){
			if(isErrorEnabled) SetError(107,VarName,cp);
			return 0;
		}
		else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
			if(isErrorEnabled) SetError(108,VarName,cp);
			return 0;
		}
	}

	//Const定義の場合は書き込みアクセスを制限する
	//※コンストラクタをコンパイル中の場合は例外的に許可する
	if( pMember->IsConst() &&		//定数メンバである
		isWriteAccess &&							//書き込みアクセスを要求されている
		pobj_c->IsCompilingConstructor() == false	//コンストラクタ コンパイル中を除く
		){
			//Const定義の変数に書き込みアクセスをしようとした場合
			SetError(61,VarName,cp);
	}

	*pType=pMember->TypeInfo.type;
	*plpNestIndex=pMember->TypeInfo.u.lpIndex;

	//ポインタ変数の場合
	if(IsPtrType(*pType)){
		if(pMember->SubScripts[0]==-1){
			lstrcpy(lpPtrOffset,array);
			array[0]=0;
		}
	}
	else{
		if(lpPtrOffset[0]){
			if(isErrorEnabled) SetError(16,member,cp);
			return 0;
		}
	}

	if(offset){
		//add r11,offset
		OpBuffer[obp++]=(char)0x49;
		OpBuffer[obp++]=(char)0x81;
		OpBuffer[obp++]=(char)0xC3;
		*((long *)(OpBuffer+obp))=offset;
		obp+=sizeof(long);
	}

	if(array[0]){
		//配列オフセット
		if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex)){
			if(isErrorEnabled) SetError(14,member,cp);
		}
	}
	else if(pMember->SubScripts[0]!=-1){
		*pType|=FLAG_PTR;
	}

	if(NestMember[0]){
		//入れ子構造の場合

		if(*pType==DEF_OBJECT && pMember->IsRef() == false){
			if(RefType!=DEF_OBJECT){
				if(isErrorEnabled) SetError(104,member,cp);
				return 0;
			}
		}
		else if(*pType==DEF_PTR_OBJECT || ( *pType==DEF_OBJECT && pMember->IsRef() )){
			//構造体ポインタ型メンバ変数

			if(lpPtrOffset[0]){
				//pObj[n].member
				if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
					if(isErrorEnabled) SetError(104,member,cp);
					return 0;
				}

				//直接参照に切り替え
				SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
				pRelativeVar->dwKind=VAR_DIRECTMEM;

				lpPtrOffset[0]=0;
			}
			else{
				//pObj->member
				if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
					if(isErrorEnabled) SetError(104,member,cp);
					return 0;
				}

				if(pRelativeVar->dwKind==VAR_DIRECTMEM){
					//mov r11,qword ptr[r11]
					op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
				}
				else{
					//直接参照に切り替え
					SetVarPtrToReg(REG_R12,pRelativeVar);
					pRelativeVar->dwKind=VAR_DIRECTMEM;

					//mov r11,qword ptr[r12]
					op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
				}
			}
		}
		else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
			//構造体ポインタのポインタ型メンバ変数

			if(lpPtrOffset[0]){
				//ppObj[n]->member
				if(RefType!=DEF_PTR_OBJECT){
					if(isErrorEnabled) SetError(104,member,cp);
					return 0;
				}

				//直接参照に切り替え
				SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
				pRelativeVar->dwKind=VAR_DIRECTMEM;

				lpPtrOffset[0]=0;

				//mov r11,qword ptr[r11]
				op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
			}
			else{
				if(isErrorEnabled) SetError(104,member,cp);
				return 0;
			}
		}

		if(!GetMemberOffset(
			isErrorEnabled,
			isWriteAccess,
			pMember->TypeInfo.u.pobj_Class,
			NestMember,
			pType,
			pRelativeVar,
			plpNestIndex,
			0)) return 0;
	}

	if(lpPtrOffset[0]){
		SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
		pRelativeVar->dwKind=VAR_DIRECTMEM;
	}

	return 1;
}
void GetWithName(char *buffer){
	extern WITHINFO WithInfo;
	int i;

	buffer[0]=0;
	for(i=0;i<WithInfo.num;i++)
		lstrcat(buffer,WithInfo.ppName[i]);
}

int LocalVar_ThisPtrOffset;
void SetThisPtrToReg(int reg){
	//自身のオブジェクトのThisポインタをregにコピー

	extern VARIABLE *LocalVar;
	RELATIVE_VAR RelativeVar;
	RelativeVar.dwKind=VAR_LOCAL;
	RelativeVar.bOffsetOffset=0;
	RelativeVar.offset=-LocalVar_ThisPtrOffset;

	SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
}
BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
	extern BOOL bCompilingGlobal;
	int i,RefType;
	char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];

	if(NameBuffer[0]=='.'){
		GetWithName(variable);
		lstrcat(variable,NameBuffer);
	}
	else lstrcpy(variable,NameBuffer);

	lstrcpy(VarName,variable);
	GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);

	LONG_PTR lpIndex;
	int *pSubScripts;
	bool bConst = false;


	if(bCompilingGlobal==0){
		//////////////////
		// ローカル変数
		//////////////////

		for(i=MaxLocalVarNum-1;i>=0;i--){	//レキシカルスコープを考慮してバックサーチ
			if( LocalVar[i].bLiving											//現在のスコープで有効なもの
				&& LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()	//現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
				){
					if(lstrcmp(VarName,LocalVar[i].name)==0) break;
			}
		}
		if(i>=0){
			//ポインタ変数の場合
			if(IsPtrType(LocalVar[i].type)){
				if(LocalVar[i].SubScripts[0]==-1){
					lstrcpy(lpPtrOffset,array);
					array[0]=0;
				}
			}
			else{
				if(lpPtrOffset[0]){
					SetError(16,variable,cp);
					pRelativeVar->dwKind=NON_VAR;
					return 0;
				}
			}

			pRelativeVar->offset=-LocalVar[i].offset;
			pRelativeVar->bOffsetOffset=0;
			if(LocalVar[i].fRef){
				// 参照型
				pRelativeVar->dwKind = VAR_REFLOCAL;
			}
			else pRelativeVar->dwKind=VAR_LOCAL;
			*pType=LocalVar[i].type;
			lpIndex=LocalVar[i].u.index;
			if(plpIndex) *plpIndex=lpIndex;
			pSubScripts=LocalVar[i].SubScripts;
			bConst = LocalVar[i].bConst;

			goto ok;
		}
	}


	if(pobj_CompilingClass){
		//////////////////////
		// クラスメンバの参照
		//////////////////////

		if(lstrcmpi(variable,"This")==0){
			//自身のオブジェクトのThisポインタをr11にコピー
			SetThisPtrToReg(REG_R11);

			*pType=DEF_OBJECT;
			pRelativeVar->dwKind=VAR_DIRECTMEM;

			if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
			return 1;
		}

		if(memicmp(variable,"This.",5)==0){
			//Thisオブジェクトのメンバを参照するとき
			SlideString(variable+5,-5);
			lstrcpy(VarName,variable);
		}
		else{
			//クラス内メンバを参照するとき（通常）

			for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
				if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
			}
			if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
		}

		//Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
		//（コンストラクタ、デストラクタ内を除く）
		CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
		if( isWriteAccess &&
			pMethod->isConst &&
			pobj_CompilingClass->IsCompilingConstructor() == false &&
			pobj_CompilingClass->IsCompilingDestructor() == false
			){
				SetError(131, NULL, cp );
		}

		//自身のオブジェクトのThisポインタをr11にコピー
		SetThisPtrToReg(REG_R11);

		pRelativeVar->dwKind=VAR_DIRECTMEM;
		if(!GetMemberOffset(
			isErrorEnabled,
			isWriteAccess,
			pobj_CompilingClass,
			variable,
			pType,
			pRelativeVar,
			&lpIndex,1)) return 0;
		if(plpIndex) *plpIndex=lpIndex;
		return 1;
	}

NonClassMember:

	//////////////////////////
	// 静的ローカル変数
	// ※"Static.Object.Method.Variable"
	//////////////////////////

	char temporary[VN_SIZE];
	extern SUBINFO *pCompilingSubInfo;
	if(pCompilingSubInfo){
		GetNowStaticVarFullName(VarName,temporary);

		for(i=0;i<MaxGlobalVarNum;i++){
			if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
		}
		if(i!=MaxGlobalVarNum){
			goto GlobalOk;
		}
	}


	//////////////////////////
	// クラスの静的メンバ
	//////////////////////////

	if(member[0]){
		lstrcpy(temporary,member);

		char tempMember[VN_SIZE];
		char tempArray[VN_SIZE];
		GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);

		char temp2[VN_SIZE];
		sprintf(temp2,"%s.%s",VarName,temporary);
		for(i=0;i<MaxGlobalVarNum;i++){
			if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
		}

		if(i!=MaxGlobalVarNum){
			lstrcpy(member,tempMember);
			lstrcpy(array,tempArray);
			goto GlobalOk;
		}
	}

	if(pobj_CompilingClass){
		//自身のクラスから静的メンバを参照する場合
		char temp2[VN_SIZE];
		sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
		for(i=0;i<MaxGlobalVarNum;i++){
			if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
		}

		if(i!=MaxGlobalVarNum){
			goto GlobalOk;
		}
	}


	/////////////////////
	// グローバル変数
	/////////////////////

	for(i=MaxGlobalVarNum-1;i>=0;i--){	//レキシカルスコープを考慮してバックサーチ
		if( GlobalVar[i].bLiving										//現在のスコープで有効なもの
			&& GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()	//現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
			){
				if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
		}
	}
	if(i>=0){
		goto GlobalOk;
	}

	if(isErrorEnabled) SetError(3,variable,cp);
	pRelativeVar->dwKind=NON_VAR;
	return 0;



GlobalOk:
	//ポインタ変数の場合
	if(IsPtrType(GlobalVar[i].type)){
		if(GlobalVar[i].SubScripts[0]==-1){
			lstrcpy(lpPtrOffset,array);
			array[0]=0;
		}
	}
	else{
		if(lpPtrOffset[0]){
			SetError(16,variable,cp);
			pRelativeVar->dwKind=NON_VAR;
			return 0;
		}
	}

	pRelativeVar->offset=GlobalVar[i].offset;
	pRelativeVar->bOffsetOffset=0;
	pRelativeVar->dwKind=VAR_GLOBAL;
	*pType=GlobalVar[i].type;
	lpIndex=GlobalVar[i].u.index;
	if(plpIndex) *plpIndex=lpIndex;
	pSubScripts=GlobalVar[i].SubScripts;
	bConst = GlobalVar[i].bConst;



ok:

	if( bConst && isWriteAccess ){
		//Const定義の変数に書き込みアクセスをしようとした場合
		if( *pType == DEF_OBJECT ){
			//オブジェクト定数
			SetError(130, VarName, cp );
		}
		else{
			//一般のConst変数
			SetError(61,VarName,cp);
		}
	}

	if(array[0]==0&&pSubScripts[0]!=-1){
		//配列の先頭ポインタを示す場合
		*pType|=FLAG_PTR;
		if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
		return 1;
	}

	if(array[0]||member[0]){
		//xor r11,r11（r11を0に初期化する）
		//※r11は変数ベースアドレスからの相対オフセットを示す
		op_zero_reg(REG_R11);

		pRelativeVar->bOffsetOffset=1;
	}
	if(array[0]){
		if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
			SetError(14,variable,cp);
			pRelativeVar->dwKind=NON_VAR;
			return 0;
		}
	}
	if(member[0]){
		if(*pType==DEF_OBJECT){
			//実態オブジェクトのメンバを参照（obj.member）
			if(RefType!=DEF_OBJECT){
				SetError(104,VarName,cp);
				pRelativeVar->dwKind=NON_VAR;
				return 0;
			}
		}
		else if(*pType==DEF_PTR_OBJECT){
			//ポインタオブジェクトが示すメンバを参照
			if(lpPtrOffset[0]){
				//pObj[n].member
				if(RefType!=DEF_OBJECT){
					SetError(104,VarName,cp);
					pRelativeVar->dwKind=NON_VAR;
					return 0;
				}
				SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
				pRelativeVar->dwKind=VAR_DIRECTMEM;
			}
			else{
				//pObj->member
				if(RefType!=DEF_PTR_OBJECT){
					SetError(104,VarName,cp);
					pRelativeVar->dwKind=NON_VAR;
					return 0;
				}

				SetVarPtrToReg(REG_R12,pRelativeVar);
				pRelativeVar->dwKind=VAR_DIRECTMEM;

				//mov r11,qword ptr[r12]
				op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
			}
		}
		else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
			//ポインタオブジェクトが示すメンバを参照
			if(lpPtrOffset[0]){
				//ppObj[n]->member
				if(RefType!=DEF_PTR_OBJECT){
					SetError(104,VarName,cp);
					pRelativeVar->dwKind=NON_VAR;
					return 0;
				}

				SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
				pRelativeVar->dwKind=VAR_DIRECTMEM;


				SetVarPtrToReg(REG_R12,pRelativeVar);

				//mov r11,qword ptr[r12]
				op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
			}
			else{
				SetError(104,VarName,cp);
				pRelativeVar->dwKind=NON_VAR;
				return 0;
			}
		}
		else{
			SetError(102,VarName,cp);
			pRelativeVar->dwKind=NON_VAR;
			return 0;
		}

		LONG_PTR lp2;
		if(!GetMemberOffset(
			isErrorEnabled,
			isWriteAccess,
			(CClass *)lpIndex,
			member,pType,pRelativeVar,&lp2,0)) return 0;
		if(plpIndex) *plpIndex=lp2;

		return 1;
	}

	if(lpPtrOffset[0]){
		SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
		pRelativeVar->dwKind=VAR_DIRECTMEM;
	}

	return 1;
}

BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
	extern BYTE *initGlobalBuf;
	int i,i2,i3,TypeSize;
	char temporary[VN_SIZE];

	if(InitBuf[0]=='['){
		SlideString(InitBuf+1,-1);
		InitBuf[lstrlen(InitBuf)-1]=0;

		TypeSize=GetTypeSize(type,lpIndex);

		if(SubScripts[0]!=-1){
			TypeSize*=JumpSubScripts(SubScripts+1);
			i=0;
			i2=0;
			while(1){
				if(SubScripts[0]<i2){
					SetError(41,0,cp);
					return 0;
				}
				i=GetOneParameter(InitBuf,i,temporary);
				if(!SetInitGlobalData(
					offset+i2*TypeSize,
					type,
					lpIndex,
					SubScripts+1,
					temporary)) return 0;
				i2++;
				if(InitBuf[i]=='\0') break;
			}
			return -1;
		}

		if(type==DEF_OBJECT){
			CClass *pobj_c;
			pobj_c=(CClass *)lpIndex;

			for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
				i=GetOneParameter(InitBuf,i,temporary);

				i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);

				if(!SetInitGlobalData(offset+i3,
					pobj_c->ppobj_Member[i2]->TypeInfo.type,
					pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
					pobj_c->ppobj_Member[i2]->SubScripts,
					temporary)) return 0;

				if(InitBuf[i]=='\0') break;
			}
			if(i2+1!=pobj_c->iMemberNum){
				SetError(41,0,cp);
				return 0;
			}
			return 1;
		}

		SetError(41,0,cp);
		return 0;
	}


	///////////////////////////////////////
	// 単発式（[]で囲まれていない）
	///////////////////////////////////////

	if( type == DEF_OBJECT){
		//オブジェクトの場合はありえない
		SetError(300,NULL,cp);
		return 0;
	}

	if(SubScripts[0]!=-1){
		SetError(41,0,cp);
		return 0;
	}

	double dbl;
	_int64 i64data;
	int CalcType;
	LONG_PTR lpCalcIndex;

	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
	if(!CalcType){
		//動的データだった場合
		return 0;
	}
	if(IsRealNumberType(CalcType)){
		memcpy(&dbl,&i64data,sizeof(double));
		i64data=(_int64)dbl;
	}
	else dbl=(double)i64data;

	//型チェック
	CheckDifferentType(
		type,
		lpIndex,
		CalcType,
		lpCalcIndex,
		0,0);

	if(type==DEF_DOUBLE)
		*(double *)(initGlobalBuf+offset)=(double)dbl;
	else if(type==DEF_SINGLE)
			*(float *)(initGlobalBuf+offset)=(float)dbl;
	else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
		if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
			//文字列定数のとき

			char *temp;
			temp=(char *)i64data;
			i2=AddDataTable(temp,lstrlen(temp));
			HeapDefaultFree(temp);

			//mov rax,DataPos
			op_mov_RV(sizeof(_int64),REG_RAX,i2);
			obp-=sizeof(long);
			pobj_DataTableSchedule->add();
			obp+=sizeof(long);

			//mov qword ptr[offset],rax
			op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
			obp-=sizeof(long);
			pobj_GlobalVarSchedule->add();
			obp+=sizeof(long);
		}
		else{
			*(_int64 *)(initGlobalBuf+offset)=i64data;
		}
	}
	else if(type==DEF_LONG||type==DEF_DWORD)
		*(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data;
	else if(type==DEF_INTEGER||type==DEF_WORD)
		*(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
	else if(type==DEF_CHAR||type==DEF_BYTE||type==DEF_BOOLEAN)
		*(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;

	return 1;
}
BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
	int i,i2,i3,TypeSize;
	char temporary[VN_SIZE];

	if(InitBuf[0]=='['){
		SlideString(InitBuf+1,-1);
		InitBuf[lstrlen(InitBuf)-1]=0;

		TypeSize=GetTypeSize(type,lpIndex);

		if(SubScripts[0]!=-1){
			TypeSize*=JumpSubScripts(SubScripts+1);
			i=0;
			i2=0;
			while(1){
				if(SubScripts[0]<i2){
					SetError(41,0,cp);
					return 0;
				}
				i=GetOneParameter(InitBuf,i,temporary);
				if(!InitLocalVar(
					offset+i2*TypeSize,
					type,
					lpIndex,
					SubScripts+1,
					temporary)) return 0;
				i2++;
				if(InitBuf[i]=='\0') break;
			}
			return -1;
		}

		if(type==DEF_OBJECT){
			CClass *pobj_c;
			pobj_c=(CClass *)lpIndex;

			for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
				i=GetOneParameter(InitBuf,i,temporary);

				i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);

				if(!InitLocalVar(offset+i3,
					pobj_c->ppobj_Member[i2]->TypeInfo.type,
					pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
					pobj_c->ppobj_Member[i2]->SubScripts,
					temporary)) return 0;

				if(InitBuf[i]=='\0') break;
			}
			if(i2+1!=pobj_c->iMemberNum){
				SetError(41,0,cp);
				return 0;
			}
			return 1;
		}

		SetError(41,0,cp);
		return 0;
	}


	///////////////////////////////////////
	// 単発式（[]で囲まれていない）
	///////////////////////////////////////

	if(SubScripts[0]!=-1){
		SetError(41,0,cp);
		return 0;
	}

	double dbl;
	_int64 i64data;
	int CalcType;
	LONG_PTR lpCalcIndex;
	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
	if(!CalcType){
		//動的データだった場合
		return 0;
	}
	if(IsRealNumberType(CalcType)){
		memcpy(&dbl,&i64data,sizeof(double));
		i64data=(_int64)dbl;
	}
	else dbl=(double)i64data;

	//型チェック
	CheckDifferentType(
		type,
		lpIndex,
		CalcType,
		lpCalcIndex,
		0,0);

	if(type==DEF_DOUBLE){
		memcpy(&i64data,&dbl,sizeof(double));

		//mov rax,i64data
		op_mov64_ToReg(REG_RAX,i64data);

		//mov qword ptr[rsp+offset],rax
		op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
		obp-=sizeof(long);
		AddLocalVarAddrSchedule();
		obp+=sizeof(long);
	}
	else if(type==DEF_SINGLE){
		float flt;
		flt=(float)dbl;

		//mov dword ptr[rsp+offset],value
		op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,*(int *)&flt);
		obp-=sizeof(long)+sizeof(long);
		AddLocalVarAddrSchedule();
		obp+=sizeof(long)+sizeof(long);
	}
	else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
		if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
			//文字列定数のとき

			char *temp;
			temp=(char *)i64data;
			i2=AddDataTable(temp,lstrlen(temp));
			HeapDefaultFree(temp);

			//mov rax,i2
			op_mov_RV(sizeof(_int64),REG_RAX,i2);
			obp-=sizeof(long);
			pobj_DataTableSchedule->add();
			obp+=sizeof(long);

			//mov qword ptr[rsp+offset],rax
			op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
			obp-=sizeof(long);
			AddLocalVarAddrSchedule();
			obp+=sizeof(long);
		}
		else{
			if(i64data&0xFFFFFFFF00000000){
				//mov rax,i64data
				op_mov64_ToReg(REG_RAX,i64data);

				//mov qword ptr[rsp+offset],rax
				op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
				obp-=sizeof(long);
				AddLocalVarAddrSchedule();
				obp+=sizeof(long);
			}
			else{
				//mov qword ptr[rsp+offset],value
				op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
				obp-=sizeof(long)+sizeof(long);
				AddLocalVarAddrSchedule();
				obp+=sizeof(long)+sizeof(long);
			}
		}
	}
	else if(type==DEF_LONG||type==DEF_DWORD){
		//mov dword ptr[rsp+offset],value
		op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
		obp-=sizeof(long)+sizeof(long);
		AddLocalVarAddrSchedule();
		obp+=sizeof(long)+sizeof(long);
	}
	else if(type==DEF_INTEGER||type==DEF_WORD){
		//mov word ptr[rsp+offset],value
		op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
		obp-=sizeof(long)+sizeof(short);
		AddLocalVarAddrSchedule();
		obp+=sizeof(long)+sizeof(short);
	}
	else if(type==DEF_CHAR||type==DEF_BYTE||type==DEF_BOOLEAN){
		//mov byte ptr[rsp+offset],value
		op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
		obp-=sizeof(long)+sizeof(char);
		AddLocalVarAddrSchedule();
		obp+=sizeof(long)+sizeof(char);
	}
	return 1;
}


void dim(char *Parameter,DWORD dwFlags){
	extern BOOL bCompilingGlobal;
	extern HANDLE hHeap;
	int i2,i3,VarSize;
	char VarName[VN_SIZE];

	//参照型かどうか
	bool isRef = false;

	i2 = 0;

	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
		//参照型
		isRef = true;
		Parameter += 2;
	}

	if(dwFlags & DIMFLAG_CONST){

		//////////////////////////////////
		// 定数変数の場合を考慮
		//////////////////////////////////
		for(;;i2++){
			if(Parameter[i2] == '=' ||
				Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
				Parameter[i2] =='('){
					VarName[i2] = 0;
					break;
			}
			VarName[i2] = Parameter[i2];
		}

		//定数と２重定義されていないる場合は抜け出す
		if(CDBConst::obj.GetType(VarName)){
			return;
		}

		//定数マクロとして定義されている場合は抜け出す
		if(GetConstHash(VarName)){
			return;
		}
	}


	//構文を解析
	int SubScripts[MAX_ARRAYDIM];
	TYPEINFO TypeInfo;
	char InitBuf[8192];
	char ConstractParameter[VN_SIZE];
	if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
		return;


	//定数と２重定義されていないかを調べる
	if(CDBConst::obj.GetType(VarName)){
		SetError(15,VarName,cp);
		return;
	}

	//定数マクロとして定義されている場合
	if(GetConstHash(VarName)){
		SetError(15,VarName,cp);
		return;
	}


	//タイプサイズを取得
	int TypeSize;
	TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);

	if(dwFlags&DIMFLAG_STATIC){
		if(bCompilingGlobal){
			SetError(60,NULL,cp);
			return;
		}

		/////////////////////
		// Static変数
		// ※"Static.Object.Method.Variable"
		/////////////////////

		char temporary[VN_SIZE];
		GetNowStaticVarFullName(VarName,temporary);

		AddGlobalVariable(temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);

		/*
		Note: 静的変数のコンストラクタ呼び出しは
			_System_InitStaticLocalVariables関数内で一括して行う
		*/
	}
	else{
		if(bCompilingGlobal){
			/////////////////////////
			// グローバル変数
			/////////////////////////

			AddGlobalVariable(VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
		}
		else{
			/////////////////
			// ローカル変数
			/////////////////

			for(i2=0;i2<MaxLocalVarNum;i2++){
				if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
					if(lstrcmp(LocalVar[i2].name,VarName)==0){
						//２重定義のエラー
						SetError(15,VarName,cp);
						return;
					}
				}
			}

			LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
			VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
			MaxLocalVarNum++;

			if( isRef ){
				//参照型
				pVar->fRef = REF_VARIABLE;
				TypeSize = PTR_SIZE;
			}
			else pVar->fRef=0;

			for(i2=1,i3=0;i3<255;i3++){
				//配列要素数
				pVar->SubScripts[i3]=SubScripts[i3];

				if(SubScripts[i3]==-1) break;
				i2*=SubScripts[i3]+1;
			}
			VarSize=TypeSize*i2;
			if(VarSize%8) VarSize+=8-(VarSize%8);

			//変数データを追加
			lstrcpy(pVar->name,VarName);
			if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
			else pVar->bConst = false;
			if(SubScripts[0]==-1) pVar->bArray=0;
			else pVar->bArray=1;
			pVar->type=TypeInfo.type;
			pVar->u.index=TypeInfo.u.lpIndex;
			AllLocalVarSize+=VarSize;
			pVar->offset=AllLocalVarSize;

			//レキシカルスコープ
			pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
			pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
			pVar->bLiving=TRUE;

			if(InitBuf[0]){
				//初期代入時のみ、書き込みアクセスを許可する
				bool bConstBack = pVar->bConst;
				pVar->bConst = false;

				int result = InitLocalVar(-pVar->offset,
					pVar->type,
					pVar->u.index,
					pVar->SubScripts,
					InitBuf);

				if(!result){
					//動的な式だった場合は代入演算を行う
					if( isRef ){
						SetRefVariable( VarName, InitBuf );
					}
					else{
						char temporary[8192];
						sprintf(temporary,"%s=%s",VarName,InitBuf);
						OpcodeCalc(temporary);
					}
				}

				pVar->bConst = bConstBack;
			}
			else{
				//0初期化

				//mov r8, 0
				op_zero_reg( REG_R8 );

				//mov rdx, VarSize
				op_mov_RV( sizeof(_int64), REG_RDX, VarSize );

				//mov rcx, rsp
				op_mov_RR( REG_RCX, REG_RSP );

				//add rcx, offset
				op_add64_value( REG_RCX, -pVar->offset );
				obp-=sizeof(long);
				AddLocalVarAddrSchedule();
				obp+=sizeof(long);

				//call FillMemory
				DECLAREINFO *pdi;
				pdi=GetDeclareHash("FillMemory");
				op_call( pdi );
			}
		}

		//コンストラクタ呼び出し
		if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
			CallConstractor(VarName,SubScripts,TypeInfo,ConstractParameter);
		}
	}

	if(TypeInfo.type==DEF_OBJECT){
		if(TypeInfo.u.pobj_Class->IsAbstract()){
			//抽象クラスだったとき
			SetError(125,TypeInfo.u.pobj_Class->name,cp);
		}
	}
}
void OpcodeDim(char *Parameter,DWORD dwFlags){
	int i,i2,i3,IsStr=0;
	char temporary[8192];

	for(i=0,i2=0;;i++,i2++){
		if(Parameter[i]=='\"') IsStr^=1;
		if(Parameter[i]=='('&&IsStr==0){
			i3=GetStringInPare(temporary+i2,Parameter+i);
			i+=i3-1;
			i2+=i3-1;
			continue;
		}
		if(Parameter[i]=='['&&IsStr==0){
			i3=GetStringInBracket(temporary+i2,Parameter+i);
			i+=i3-1;
			i2+=i3-1;
			continue;
		}
		if((Parameter[i]==','&&IsStr==0)||
			Parameter[i]=='\0'){
			temporary[i2]=0;

			dim(temporary,dwFlags);

			if(Parameter[i]=='\0') break;
			i2=-1;
			continue;
		}
		temporary[i2]=Parameter[i];
	}
}

void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
	if(!IsGeneralReg(reg)) SetError(300,NULL,cp);

	if(pRelativeVar->dwKind==VAR_GLOBAL){
		if(pRelativeVar->bOffsetOffset){
			//add r11,offset
			OpBuffer[obp++]=(char)0x49;
			OpBuffer[obp++]=(char)0x81;
			OpBuffer[obp++]=(char)0xC3;
			*((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
			pobj_GlobalVarSchedule->add();
			obp+=sizeof(long);

			//mov reg,r11
			op_mov64_ToReg_FromReg(reg,REG_R11);
		}
		else{
			//mov reg,offset
			op_mov64_ToReg(reg,(int)pRelativeVar->offset);
			obp-=sizeof(long);
			pobj_GlobalVarSchedule->add();
			obp+=sizeof(long);
		}
	}
	else if(pRelativeVar->dwKind==VAR_LOCAL){
		if(pRelativeVar->bOffsetOffset){
			//add r11,offset
			OpBuffer[obp++]=(char)0x49;
			OpBuffer[obp++]=(char)0x81;
			OpBuffer[obp++]=(char)0xC3;
			*((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
			AddLocalVarAddrSchedule();
			obp+=sizeof(long);

			//add r11,rsp
			op_add64_reg(REG_R11,REG_RSP);

			//mov reg,r11
			op_mov64_ToReg_FromReg(reg,REG_R11);
		}
		else{
			//mov reg,rsp
			op_mov64_ToReg_FromReg(reg,REG_RSP);

			//add reg,offset
			op_add64_value(reg,(int)pRelativeVar->offset);
			obp-=sizeof(long);
			AddLocalVarAddrSchedule();
			obp+=sizeof(long);
		}
	}
	else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
		if(pRelativeVar->bOffsetOffset){
			//add r11,qword ptr[rsp+offset]
			OpBuffer[obp++]=(char)0x4C;
			OpBuffer[obp++]=(char)0x03;
			OpBuffer[obp++]=(char)0x9C;
			OpBuffer[obp++]=(char)0x24;
			*((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
			AddLocalVarAddrSchedule();
			obp+=sizeof(long);
		}
		else{
			//mov r11,qword ptr[rsp+offset]
			op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
			obp-=sizeof(long);
			AddLocalVarAddrSchedule();
			obp+=sizeof(long);
		}

		goto directmem;
	}
	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
directmem:
		//mov reg,r11
		op_mov64_ToReg_FromReg(reg,REG_R11);
	}
}