Context Navigation

source: dev/trunk/abdev/BasicCompiler32/Compile_Var.cpp@ 264

Last change on this file since 264 was 256, checked in by dai_9181, 17 years ago
MetaImplを廃止し、Metaにした。 ObjectModuleクラス、Linkerクラスを用意。
File size: 33.2 KB

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

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

Download in other formats: