Context Navigation

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

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

File size: 32.3 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
	6	#include <LexicalScopingImpl.h>
	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];
[193]	364	compiler.GetMeta().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	//（コンストラクタ、デストラクタ内を除く）
[193]	458	const CMethod *pMethod = compiler.GetMeta().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
[206]	498	pVar = compiler.GetMeta().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
[193]	521	int typeDefIndex = compiler.GetMeta().GetTypeDefs().GetIndex( VarName );
[116]	522	if( typeDefIndex != -1 ){
	523	// TypeDef後の型名だったとき
[193]	524	lstrcpy( VarName, compiler.GetMeta().GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
[116]	525	}
	526
[75]	527	char temp2[VN_SIZE];
	528	sprintf(temp2,"%s.%s",VarName,temporary);
[206]	529	pVar = compiler.GetMeta().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);
	541	pVar = compiler.GetMeta().GetGlobalVars().Find( Symbol( temp2 ) );
[75]	542	if( pVar ){
	543	goto GlobalOk;
	544	}
[3]	545	}
	546
[75]	547	/////////////////////
	548	// グローバル変数
	549	/////////////////////
[3]	550
[206]	551	pVar = compiler.GetMeta().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;
[224]	839	i2=compiler.GetDataTable().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
[231]	965	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset+sizeof(long), MOD_BASE_DISP32, Schedule::LocalVar );
[3]	966
	967	//mov eax,LOLONG(dbl)
[231]	968	compiler.codeGenerator.op_mov_RV( REG_EAX, (long )(&dbl) );
[3]	969
	970	//mov dword ptr[ebp+offset],eax
[237]	971	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	972	}
[75]	973	else if( type.IsSingle() ){
[3]	974	float flt;
	975	flt=(float)dbl;
[231]	976
[3]	977	//mov eax,InitValue
[231]	978	compiler.codeGenerator.op_mov_RV( REG_EAX, (long )&flt );
[3]	979
	980	//mov dword ptr[ebp+offset],eax
[231]	981	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	982	}
[75]	983	else if( type.Is64() ){
[3]	984	//mov eax,HILONG(i64data)
[231]	985	compiler.codeGenerator.op_mov_RV( REG_EAX, (long )(((char *)(&i64data))+4) );
[3]	986
	987	//mov dword ptr[ebp+offset+sizeof(long)],eax
[231]	988	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset+sizeof(long), MOD_BASE_DISP32, Schedule::LocalVar );
[3]	989
	990	//mov eax,LOLONG(i64data)
[231]	991	compiler.codeGenerator.op_mov_RV( REG_EAX, (long )(&i64data) );
[3]	992
	993	//mov dword ptr[ebp+offset],eax
[237]	994	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	995	}
[75]	996	else if( type.IsDWord() \|\| type.IsLong() \|\| type.IsPointer() ){
[97]	997	if(type.GetBasicType()==typeOfPtrChar){
[3]	998	//文字列定数のとき
	999
	1000	char *temp;
	1001	temp=(char *)i64data;
[224]	1002	i2=compiler.GetDataTable().AddString(temp,lstrlen(temp));
[3]	1003	HeapDefaultFree(temp);
	1004
	1005	//mov eax,DataPos
[237]	1006	compiler.codeGenerator.op_mov_RV( REG_EAX, i2, Schedule::DataTable );
[3]	1007	}
	1008	else{
	1009	//mov eax,InitValue
[231]	1010	compiler.codeGenerator.op_mov_RV( REG_EAX, (long)i64data );
[3]	1011	}
	1012
	1013	//mov dword ptr[ebp+offset],eax
[231]	1014	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_EBP, offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	1015	}
[75]	1016	else if( type.IsWord() \|\| type.IsInteger() ){
[234]	1017	//mov word ptr[ebp+offset],InitValue
	1018	compiler.codeGenerator.op_mov_MV( sizeof(short), REG_EBP, offset, Schedule::LocalVar, (long)i64data );
[3]	1019	}
[75]	1020	else if( type.IsSByte() \|\| type.IsByte() \|\| type.IsBoolean() ){
[3]	1021	//mov byte ptr[ebp+offset],InitValue
[234]	1022	compiler.codeGenerator.op_mov_MV( sizeof(char), REG_EBP, offset, Schedule::LocalVar, (long)i64data );
[3]	1023	}
[75]	1024
	1025	return true;
[3]	1026	}
	1027
[206]	1028	void dim( char VarName, const Subscripts &subscripts, Type &type,const char InitBuf,const char *ConstractParameter,DWORD dwFlags){
[75]	1029	if( UserProc::IsGlobalAreaCompiling() ){
[64]	1030	/////////////////////////
	1031	// グローバル変数
	1032	/////////////////////////
	1033
[206]	1034	AddGlobalVariable(VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags);
[64]	1035	}
	1036	else{
	1037	/////////////////
	1038	// ローカル変数
	1039	/////////////////
	1040
[206]	1041	if( UserProc::CompilingUserProc().GetLocalVars().DuplicateCheck( Symbol( VarName ) ) ){
[75]	1042	//２重定義のエラー
	1043	SetError(15,VarName,cp);
	1044	return;
[64]	1045	}
	1046
[75]	1047	bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
[64]	1048
[206]	1049	Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter );
[75]	1050
[206]	1051	if( subscripts.size() > 0 ){
[75]	1052	//配列あり
[206]	1053	pVar->SetArray( subscripts );
[64]	1054	}
	1055
[75]	1056	//レキシカルスコープ
[206]	1057	pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
	1058	pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
[75]	1059	pVar->bLiving=TRUE;
	1060
	1061	//エラー用
	1062	pVar->source_code_address=cp;
	1063
	1064	// 変数を追加
[206]	1065	UserProc::CompilingUserProc().GetLocalVars().push_back( pVar );
[75]	1066
	1067	//アラインメントを考慮
[206]	1068	if( pVar->GetType().IsStruct() ){
[233]	1069	int alignment = pVar->GetType().GetClass().GetFixedAlignment();
[120]	1070
[75]	1071	if( alignment ){
	1072	if( AllLocalVarSize % alignment ){
	1073	AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
	1074	}
	1075	}
[120]	1076
	1077	if( alignment == PTR_SIZE*2 ){
	1078	// ポインタに要するサイズよりも一回り大きなアラインメントが指定されているとき
	1079	// （例:CONTEXT構造体など）
	1080	// 呼び出し側のオフセットズレを考慮する
	1081
	1082	if( 0 == ( UserProc::CompilingUserProc().RealParams().GetMemorySize() + PTR_SIZE/ret分/ ) % alignment ){
	1083	AllLocalVarSize += PTR_SIZE;
	1084	}
	1085	}
[64]	1086	}
	1087
[75]	1088	AllLocalVarSize += pVar->GetMemorySize();
[206]	1089	pVar->SetOffsetAddress( AllLocalVarSize );
[64]	1090
	1091	//レキシカルスコープ
[206]	1092	pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
	1093	pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
[64]	1094	pVar->bLiving=TRUE;
	1095
	1096	if(InitBuf[0]){
	1097	//初期代入時のみ、書き込みアクセスを許可する
[75]	1098	if( isConst ){
	1099	pVar->ConstOff();
	1100	}
[64]	1101
	1102	int result = 0;
[206]	1103	if( !pVar->GetType().IsObject() ){
	1104	result = InitLocalVar(-pVar->GetOffsetAddress(),
	1105	pVar->GetType(),
	1106	pVar->GetSubscripts(),
[64]	1107	InitBuf);
	1108	}
	1109
	1110	if(!result){
	1111	//動的な式だった場合は代入演算を行う
	1112	char temporary[8192];
	1113	sprintf(temporary,"%s=%s",VarName,InitBuf);
	1114	OpcodeCalc(temporary);
	1115	}
	1116
[75]	1117	if( isConst ){
	1118	pVar->ConstOn();
	1119	}
[64]	1120	}
	1121	else{
	1122	//push 0
[225]	1123	compiler.codeGenerator.op_push_V(0);
[64]	1124
	1125	//push VarSize
[225]	1126	compiler.codeGenerator.op_push_V( pVar->GetMemorySize() );
[64]	1127
	1128	//mov eax,ebp
[241]	1129	compiler.codeGenerator.op_mov_RR( REG_EAX, REG_EBP );
[64]	1130
	1131	//add eax,offset
[234]	1132	compiler.codeGenerator.op_add_RV( REG_EAX, -pVar->GetOffsetAddress(), Schedule::LocalVar );
[64]	1133
	1134	//push eax
[225]	1135	compiler.codeGenerator.op_push(REG_EAX);
[64]	1136
	1137	//call FillMemory
	1138	OpBuffer[obp++]=(char)0xFF;
	1139	OpBuffer[obp++]=(char)0x15;
[75]	1140	DllProc *pDllProc = GetDeclareHash("FillMemory");
	1141	pDllProc->Using();
	1142	pobj_ImportAddrSchedule->add(pDllProc);
[64]	1143	obp+=sizeof(long);
	1144	}
	1145	}
	1146
	1147	//New呼び出し
[75]	1148	if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
[64]	1149	char objectSize[255];
[206]	1150	if( subscripts.size() == 0 ){
[64]	1151	objectSize[0] = 0;
	1152	}
	1153	else{
[206]	1154	if( subscripts.size() > 1 ){
[64]	1155	SetError(300,NULL,cp);
	1156	}
[206]	1157	sprintf( objectSize, "%d", subscripts[0] );
[64]	1158	}
[75]	1159	Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
[64]	1160
	1161	//pop eax
[225]	1162	compiler.codeGenerator.op_pop( REG_EAX );
[64]	1163
	1164	RELATIVE_VAR RelativeVar;
[75]	1165	GetVarOffset( true, false, VarName, &RelativeVar, Type() );
[64]	1166	if( RelativeVar.dwKind == VAR_DIRECTMEM ){
	1167	SetError();
	1168	}
	1169	SetVariableFromEax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
	1170	}
	1171	}
[3]	1172
	1173	void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar){
	1174	if(pRelativeVar->dwKind==VAR_GLOBAL){
	1175	if(pRelativeVar->bOffsetOffset){
	1176	//lea eax,dword ptr[ecx+offset]
[230]	1177	compiler.codeGenerator.op_lea_RM( REG_EAX, REG_ECX, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::GlobalVar );
[3]	1178	}
	1179	else{
	1180	//mov eax,offset
[230]	1181	compiler.codeGenerator.op_mov_RV( REG_EAX, pRelativeVar->offset, Schedule::GlobalVar );
[3]	1182	}
	1183	}
[62]	1184	else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
	1185	if(pRelativeVar->bOffsetOffset){
	1186	//mov eax,ecx
[241]	1187	compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ECX );
[62]	1188
	1189	//add eax,dword ptr[offset]
[230]	1190	compiler.codeGenerator.op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
[62]	1191	}
	1192	else{
	1193	//mov eax,dword ptr[offset]
[230]	1194	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
[62]	1195	}
	1196	}
[3]	1197	else if(pRelativeVar->dwKind==VAR_LOCAL){
	1198	if(pRelativeVar->bOffsetOffset){
	1199	//add ecx,offset
[230]	1200	compiler.codeGenerator.op_add_RV( REG_ECX, pRelativeVar->offset, Schedule::LocalVar );
[3]	1201
	1202	//lea eax,dword ptr[ebp+ecx]
[241]	1203	compiler.codeGenerator.PutOld(
	1204	(char)0x8D,
	1205	(char)0x44,
	1206	(char)0x0D,
	1207	(char)0x00
	1208	);
[3]	1209	}
	1210	else{
[230]	1211	//lea eax,dword ptr[ecx+offset]
	1212	compiler.codeGenerator.op_lea_RM( REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	1213	}
	1214	}
	1215	else if(pRelativeVar->dwKind==VAR_REFLOCAL){
	1216	if(pRelativeVar->bOffsetOffset){
	1217	//mov eax,ecx
[231]	1218	compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ECX );
[3]	1219
	1220	//add eax,dword ptr[ebp+offset]
[231]	1221	compiler.codeGenerator.op_add_RM( sizeof(long), REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	1222	}
	1223	else{
	1224	//mov eax,dword ptr[ebp+offset]
[231]	1225	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EBP, pRelativeVar->offset, MOD_BASE_DISP32, Schedule::LocalVar );
[3]	1226	}
	1227	}
	1228	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
	1229	//mov eax,ecx
[231]	1230	compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ECX );
[3]	1231	}
	1232	}
[97]	1233	void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
	1234	if( reg != REG_EAX ){
	1235	SetError();
	1236	//TODO: 未完成
	1237	}
	1238	SetVarPtrToEax( pRelativeVar );
	1239	}
[95]	1240
	1241	bool Compile_AddGlobalRootsForGc(){
[206]	1242	const UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
[95]	1243	if( !pUserProc_AddGlobalRootPtr ){
	1244	SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
	1245	return false;
	1246	}
	1247
[206]	1248	BOOST_FOREACH( const Variable *pVar, compiler.GetMeta().GetGlobalVars() ){
	1249	if( pVar->GetType().IsObject() \|\| pVar->GetType().IsPointer() \|\| pVar->GetType().IsStruct() ){
[95]	1250	// オブジェクトまたはポインタだったとき
	1251	// ※構造体も含む（暫定対応）
	1252
	1253	// 変数領域に要するLONG_PTR単位の個数を引き渡す
[225]	1254	compiler.codeGenerator.op_push_V( pVar->GetMemorySize()/PTR_SIZE );
[95]	1255
	1256
	1257	/////////////////////////////
	1258	// ルートポインタを引き渡す
	1259
	1260	//mov eax,offset
[231]	1261	compiler.codeGenerator.op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress(), Schedule::GlobalVar );
[95]	1262
	1263	//push eax
[225]	1264	compiler.codeGenerator.op_push( REG_EAX );
[95]	1265
	1266	//
	1267	/////////////////////////////
	1268
	1269
	1270	/////////////////////////////
	1271	// Thisポインタを引き渡す
	1272
	1273	SetThisPtrToReg(REG_EAX);
	1274
	1275	//push eax
[225]	1276	compiler.codeGenerator.op_push( REG_EAX );
[95]	1277
	1278	//
	1279	/////////////////////////////
	1280
	1281
	1282	// call AddGlobalRootPtr
[225]	1283	compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
[95]	1284
	1285	ReallocNativeCodeBuffer();
	1286	}
	1287	}
	1288
	1289	return true;
	1290	}

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

Download in other formats: