Context Navigation

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

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

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

Download in other formats: