Context Navigation

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

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

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

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

Download in other formats: