Context Navigation

source: dev/BasicCompiler64/Compile_Var.cpp@ 20

Last change on this file since 20 was 20, checked in by dai_9181, 17 years ago
参照型パラメータに関数の戻り値オブジェクトを指定した場合などの、一時オブジェクトの扱いを可能にした。 Dimで指定される初期値を見分けることで、As指定を省略できるようにした。
File size: 31.4 KB

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

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

Download in other formats: