Context Navigation

source: dev/BasicCompiler32/Compile_Var.cpp@ 27

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

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

Download in other formats: