Context Navigation

source: dev/trunk/ab5.0/abdev/BasicCompiler64/Compile_Var.cpp@ 461

Last change on this file since 461 was 454, checked in by dai_9181, 17 years ago
[453]を64bit版にマージ。
File size: 34.5 KB

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

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

Download in other formats: