Context Navigation

source: dev/trunk/abdev/BasicCompiler64/Compile_Var.cpp@ 198

Last change on this file since 198 was 198, checked in by dai_9181, 17 years ago

File size: 32.3 KB

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

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

Download in other formats: