Context Navigation

source: dev/BasicCompiler32/Compile_Var.cpp@ 63

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

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

Download in other formats: