Context Navigation

source: dev/BasicCompiler32/Compile_Var.cpp@ 62

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

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

Download in other formats: