Context Navigation

source: dev/trunk/ab5.0/abdev/compiler_x86/Compile_Func.cpp@ 687

Last change on this file since 687 was 687, checked in by dai_9181, 16 years ago
・VarPtr(This)をエラーとして扱うようにした。・デリゲート生成時にThisに対するオブジェクトポインタが正常に取得できないバグを修正。
File size: 23.1 KB

Line
1	#include "stdafx.h"
2
3	#include <Compiler.h>
4
5	#include "../BasicCompiler_Common/common.h"
6	#include "Opcode.h"
7
8	#include "FunctionValue.h"
9
10	void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn );
11
12	int GetFunctionFromName(char *FuncName){
13	if( lstrcmpi( FuncName, "CUDbl" ) == 0 ) return FUNC_CUDBL;
14	if( lstrcmpi( FuncName, "Fix" ) == 0 ) return FUNC_FIX;
15	if( lstrcmpi( FuncName, "Len" ) == 0 ) return FUNC_LEN;
16	if( lstrcmpi( FuncName, "AddressOf" ) == 0 ) return FUNC_ADDRESSOF;
17	if( lstrcmpi( FuncName, "SizeOf" ) == 0 ) return FUNC_SIZEOF;
18	if( lstrcmpi( FuncName, "__ClassSizeOf" ) == 0 ) return FUNC_CLASS_SIZEOF;
19	if( lstrcmpi( FuncName, "VarPtr" ) == 0 ) return FUNC_VARPTR;
20	if( lstrcmpi( FuncName, "ObjPtr" ) == 0 ) return FUNC_OBJPTR;
21	if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 ) return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
22	if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 ) return FUNC_DELEGATE_STATICMETHOD_CALL;
23	if( lstrcmpi( FuncName, "_System_GetNowScopeCatchAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS;
24	if( lstrcmpi( FuncName, "_System_GetNowScopeFinallyAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS;
25	if( lstrcmpi( FuncName, "_System_GetBp" ) == 0 ) return FUNC_SYSTEM_GET_BP;
26	if( lstrcmpi( FuncName, "_System_GetSp" ) == 0 ) return FUNC_SYSTEM_GET_SP;
27	if( lstrcmp( FuncName, "_System_GetComVtbl" ) == 0 ) return FUNC_SYSTEM_GET_COM_VTBL;
28	if( lstrcmp( FuncName, "_System_GetVtblList" ) == 0 ) return FUNC_SYSTEM_GET_VTBL_LIST;
29	if( lstrcmp( FuncName, "_System_GetDefaultConstructor" ) == 0 ) return FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR;
30	if( lstrcmp( FuncName, "_System_GetDestructor" ) == 0 ) return FUNC_SYSTEM_GET_DESTRUCTOR;
31	if( lstrcmpi( FuncName, "GetDouble" ) == 0 ) return FUNC_GETDOUBLE;
32	if( lstrcmpi( FuncName, "GetSingle" ) == 0 ) return FUNC_GETSINGLE;
33	if( lstrcmpi( FuncName, "GetQWord" ) == 0 ) return FUNC_GETQWORD;
34	if( lstrcmpi( FuncName, "GetDWord" ) == 0 ) return FUNC_GETDWORD;
35	if( lstrcmpi( FuncName, "GetWord" ) == 0 ) return FUNC_GETWORD;
36	if( lstrcmpi( FuncName, "GetByte" ) == 0 ) return FUNC_GETBYTE;
37	return 0;
38	}
39
40	void Opcode_Func_Fix(const char *lpszParms){
41	Type resultType;
42	if( !NumOpe( lpszParms, Type(), resultType ) ){
43	return;
44	}
45
46	if( resultType.IsDouble() ){
47	//fld qword ptr[esp]
48	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
49
50	//fnstcw word ptr[esp]
51	compiler.codeGenerator.PutOld(
52	(char)0xD9,
53	(char)0x3C,
54	(char)0x24
55	);
56
57	//mov ax,word ptr[esp]
58	compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
59
60	//or ah,0Ch
61	compiler.codeGenerator.PutOld(
62	(char)0x80,
63	(char)0xCC,
64	(char)0x0C
65	);
66
67	//mov word ptr[esp-2],ax
68	compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
69
70	//fldcw word ptr[esp-2]
71	compiler.codeGenerator.PutOld(
72	(char)0xD9,
73	(char)0x6C,
74	(char)0x24,
75	(char)0xFE
76	);
77
78	//fistp dword ptr[esp+4]
79	compiler.codeGenerator.PutOld(
80	(char)0xDB,
81	(char)0x5C,
82	(char)0x24,
83	(char)0x04
84	);
85
86	//fldcw word ptr[esp]
87	compiler.codeGenerator.PutOld(
88	(char)0xD9,
89	(char)0x2C,
90	(char)0x24
91	);
92
93	//add esp,4
94	compiler.codeGenerator.op_add_esp(4);
95	}
96	else if( resultType.IsSingle() ){
97	//fld dword ptr[esp]
98	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
99
100	//sub esp,4
101	compiler.codeGenerator.op_sub_esp(4);
102
103	//fnstcw word ptr[esp]
104	compiler.codeGenerator.PutOld(
105	(char)0xD9,
106	(char)0x3C,
107	(char)0x24
108	);
109
110	//mov ax,word ptr[esp]
111	compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
112
113	//or ah,0Ch
114	compiler.codeGenerator.PutOld(
115	(char)0x80,
116	(char)0xCC,
117	(char)0x0C
118	);
119
120	//mov word ptr[esp-2],ax
121	compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
122
123	//fldcw word ptr[esp-2]
124	compiler.codeGenerator.PutOld(
125	(char)0xD9,
126	(char)0x6C,
127	(char)0x24,
128	(char)0xFE
129	);
130
131	//fistp dword ptr[esp+4]
132	compiler.codeGenerator.PutOld(
133	(char)0xDB,
134	(char)0x5C,
135	(char)0x24,
136	(char)0x04
137	);
138
139	//fldcw word ptr[esp]
140	compiler.codeGenerator.PutOld(
141	(char)0xD9,
142	(char)0x2C,
143	(char)0x24
144	);
145
146	//add esp,4
147	compiler.codeGenerator.op_add_esp(4);
148	}
149	else if( resultType.Is64() ){
150	//pop eax
151	compiler.codeGenerator.op_pop(REG_EAX);
152
153	//add esp,4
154	compiler.codeGenerator.op_add_esp(4);
155
156	//push eax
157	compiler.codeGenerator.op_push(REG_EAX);
158	}
159
160	//pop eax
161	compiler.codeGenerator.op_pop(REG_EAX);
162	}
163
164	void Opcode_Func_CUDbl(const char *Parameter){
165	Type resultType;
166	if( !NumOpe(Parameter,Type(),resultType) ){
167	return;
168	}
169	ChangeTypeToLong(resultType.GetBasicType());
170
171	//pop eax
172	compiler.codeGenerator.op_pop(REG_EAX);
173
174	//push 0
175	compiler.codeGenerator.op_push_V( 0 );
176
177	//push eax
178	compiler.codeGenerator.op_push(REG_EAX);
179
180	//fild qword ptr[esp]
181	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
182
183	//add esp,8
184	compiler.codeGenerator.op_add_esp(8);
185	}
186	void Opcode_Func_Len(const char *Parameter){
187	BOOL bArrayHead;
188
189	const char *tempParm=Parameter;
190	char temporary[VN_SIZE];
191	char temp2[32];
192	Type type;
193	if( !GetVarType(Parameter,type,0) ){
194	sprintf(temporary,"_System_DummyStr2=%s",Parameter);
195	OpcodeCalc(temporary);
196
197	lstrcpy(temp2,"_System_DummyStr2");
198	tempParm=temp2;
199
200	type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
201	}
202
203	if( type.IsStringClass() ){
204	//Stringオブジェクトの場合
205	sprintf(temporary,"%s.Length",tempParm);
206
207	int reg=REG_RAX;
208	NumOpe(temporary,Type(),Type());
209
210	//pop eax
211	compiler.codeGenerator.op_pop(REG_EAX);
212
213	return;
214	}
215
216	Subscripts subscripts;
217	RELATIVE_VAR RelativeVar;
218	if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
219
220	if(type.GetBasicType()&FLAG_PTR){
221	type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
222
223	bArrayHead=1;
224	}
225	else bArrayHead=0;
226
227	int typeSize = type.GetSize();
228
229	if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
230
231	//mov eax,typeSize
232	compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
233	}
234
235	void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
236	{
237	if( userProc.IsVirtual() ){
238	///////////////////////////////
239	// 仮想関数の場合
240	// thisポインタをrcxにコピー
241	///////////////////////////////
242
243	const CClass *pobj_c;
244
245	char ObjectName[VN_SIZE];
246	ReferenceKind referenceKind;
247	SplitObjectName( methodInstanceName, ObjectName, referenceKind );
248
249	if(ObjectName[0]){
250	if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
251	else{
252	RELATIVE_VAR RelativeVar;
253	Type type;
254	if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
255	SetVarPtrToEax(&RelativeVar);
256
257	//mov ecx,eax
258	compiler.codeGenerator.op_mov_RR(REG_ECX,REG_EAX);
259
260	//参照タイプが整合しているかをチェック
261	if( !( type.IsObject() && referenceKind == RefDot
262	\|\| type.IsObjectPtr() && referenceKind == RefPointer ) )
263	{
264	compiler.errorMessenger.Output(104,ObjectName,cp);
265	}
266
267	if(type.IsObjectPtr()){
268	//mov ecx,dword ptr[ecx]
269	compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);
270	}
271	}
272	}
273	else{
274	InClassMember:
275	//自身のオブジェクトのThisポインタをrcxにコピー
276	SetThisPtrToReg(REG_RCX);
277
278	pobj_c = &compiler.GetCompilingClass();
279	}
280
281
282	int vtblIndex;
283	if( pobj_c->IsInterface() )
284	{
285	// インターフェイスメソッド呼び出し
286
287	int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
288
289
290	// vtblのポインタを取得
291	//mov edx,dword ptr[ecx+offset_vtbl]
292	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
293
294	int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
295
296
297
298	// インターフェイスの場合は更に__thisを取得する
299	//mov rcx,qword ptr[rcx+offset_this]
300	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
301
302	int vtblMasterListIndex;
303	pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
304	if( vtblMasterListIndex != 0 )
305	{
306	compiler.errorMessenger.OutputFatalError();
307	}
308	}
309	else if( pobj_c->IsComInterface() )
310	{
311	// COMインターフェイスメソッド呼び出し
312
313	//仮想関数（オブジェクトメソッド）呼び出し
314	// pObj -> vtbl1 -> func1
315	// -> func2
316	// -> func3
317
318	int vtblMasterListIndex;
319	pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
320
321	// vtblのポインタを取得
322	//mov edx,dword ptr[ecx]
323	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
324	}
325	else
326	{
327	//仮想関数（オブジェクトメソッド）呼び出し
328	// pObj -> vtbl_master_list -> vtbl1 -> func1
329	// -> func2
330	// -> func3
331	// -> vtbl2 -> func1
332	// -> func2
333	// -> func3
334
335	int vtblMasterListIndex;
336	pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
337
338	// vtblマスターリストのポインタを取得
339	//mov edx,dword ptr[ecx+sizeof(com_vtbl)]
340	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, PTR_SIZE, MOD_BASE_DISP8 );
341
342	// vtblのポインタを取得
343	//mov edx,dword ptr[edx+vtblMasterListIndex]
344	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
345	}
346
347	//mov eax,dword ptr[edx+func_index]
348	if( vtblIndex * PTR_SIZE <= 0x7F )
349	{
350	compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP8);
351	}
352	else{
353	compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP32);
354	}
355	}
356	else{
357	//一般の関数
358
359	//mov eax,ProcAddr
360	compiler.codeGenerator.op_addressof( REG_EAX, &userProc );
361	}
362
363	userProc.Using();
364	}
365	void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
366	{
367	/////////////////////////////////////////////////////////////////
368	// 関数ポインタをpush
369	/////////////////////////////////////////////////////////////////
370
371	//push AddressOf(userProc)
372	_Opcode_Func_AddressOf( methodInstanceName, userProc );
373	compiler.codeGenerator.op_push( REG_EAX );
374
375
376	if( userProc.GetMethod().IsDynamic() )
377	{
378	/////////////////////////////////////////////////////////////////
379	// オブジェクトポインタをpush
380	/////////////////////////////////////////////////////////////////
381
382	// オブジェクト名を取得
383	char objectName[VN_SIZE];
384	char memberName[VN_SIZE];
385	char *thisPtrName = "This";
386	Type type;
387	if( SplitMemberName( methodInstanceName, objectName, memberName ) )
388	{
389	if( GetVarType( objectName, type, false ) )
390	{
391	thisPtrName = objectName;
392	}
393	}
394
395	// オブジェクトポインタを取得
396	Opcode_Func_ObjPtr( thisPtrName, type, true );
397
398	//push eax
399	compiler.codeGenerator.op_push( REG_EAX );
400	}
401
402
403	/////////////////////////////////////////////////////////////////
404	// call _CreateDynamicDelegate/_CreateStaticDelegate
405	/////////////////////////////////////////////////////////////////
406
407	std::vector<const UserProc *> subs;
408	if( userProc.GetMethod().IsDynamic() )
409	{
410	dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
411	}
412	else
413	{
414	dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
415	}
416
417	// call _CreateDynamicDelegate
418	compiler.codeGenerator.op_call( subs[0] );
419	}
420	void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
421	{
422	extern int cp;
423
424	const Parameters *pBaseParams = NULL;
425	const Type *pBaseReturnType = NULL;
426	if( baseType.IsProcPtr() )
427	{
428	// 左辺で関数ポインタを要求されているとき
429	const ProcPointer *pTempProcPointer = compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()];
430	pBaseParams = &pTempProcPointer->Params();
431	pBaseReturnType = &pTempProcPointer->ReturnType();
432	}
433	else if( baseType.IsDelegate() )
434	{
435	// 左辺でデリゲートを要求されているとき
436	const Delegate *pTempDelegate = &compiler.GetObjectModule().meta.ToDelegate( baseType.GetClass() );
437	pBaseParams = &pTempDelegate->Params();
438	pBaseReturnType = &pTempDelegate->ReturnType();
439	}
440
441	const UserProc *pUserProc;
442	if( pBaseParams && pBaseReturnType )
443	{
444	//左辺の型にのっとり、オーバーロードを解決
445
446	std::vector<const UserProc *> subs;
447	GetOverloadSubHash( name, subs );
448	if( subs.size() == 0 ){
449	compiler.errorMessenger.Output(27,name,cp);
450	return;
451	}
452
453	//オーバーロードを解決
454	pUserProc=OverloadSolution( name, subs, *pBaseParams, Type(), Type() );
455
456	if( isCallOn )
457	{
458	// コード生成を伴う場合はエラーチェックを行う
459
460	if( baseType.IsDelegate() )
461	{
462	// デリゲート
463	// 共変戻り値、反変引数をサポート
464	if( !(
465	pBaseParams->Equals( pUserProc->Params(), true )
466	&& ( pBaseReturnType->Equals( pUserProc->ReturnType() ) \|\| pBaseReturnType->IsCovariant( pUserProc->ReturnType() ) )
467	) )
468	{
469	compiler.errorMessenger.Output(67, name, cp );
470	}
471	}
472	else
473	{
474	// 関数ポインタ
475	if( !(
476	pBaseParams->Equals( pUserProc->Params() )
477	&& pBaseReturnType->Equals( pUserProc->ReturnType() )
478	) )
479	{
480	compiler.errorMessenger.Output(66, name, cp );
481	}
482	}
483	}
484
485	if(!pUserProc){
486	compiler.errorMessenger.Output(27,name,cp);
487	return;
488	}
489	}
490	else{
491	pUserProc=GetSubHash(name);
492	if(!pUserProc){
493	compiler.errorMessenger.Output(27,name,cp);
494	return;
495	}
496	}
497
498	if( baseType.IsDelegate() )
499	{
500	if( isCallOn )
501	{
502	// デリゲートのとき
503	Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
504	}
505	resultType = baseType;
506	}
507	else
508	{
509	if( isCallOn )
510	{
511	// 関数ポインタのとき
512	_Opcode_Func_AddressOf( name, *pUserProc );
513	}
514	resultType.SetBasicType( DEF_PTR_VOID );
515	}
516	}
517	void Opcode_Func_SizeOf( const std::string &typeName )
518	{
519	Type tempType;
520	if( !compiler.StringToType( typeName, tempType ) ){
521	compiler.errorMessenger.Output(3,typeName,cp);
522	return;
523	}
524
525	//mov eax,size
526	compiler.codeGenerator.op_mov_RV( REG_EAX, compiler.SizeOf( tempType ) );
527	}
528	void Opcode_Func_ClassSizeOf( const std::string &typeName )
529	{
530	Type tempType;
531	if( !compiler.StringToType( typeName, tempType ) ){
532	compiler.errorMessenger.Output(3,typeName,cp);
533	return;
534	}
535
536	if( !tempType.IsObject() )
537	{
538	compiler.errorMessenger.Output(1,typeName,cp);
539	return;
540	}
541
542	//mov eax,size
543	compiler.codeGenerator.op_mov_RV( REG_EAX, tempType.GetClass().GetSize() );
544	}
545	void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn )
546	{
547	if( isCallOn == false )
548	{
549	// 戻り値の型を取得するだけ
550
551	//変数のアドレスを取得
552	if(!GetVarType( Parameter, resultType, true )) return;
553
554	resultType.PtrLevelUp();
555
556	return;
557	}
558
559	if( lstrcmpi( Parameter, "This" )==0 )
560	{
561	compiler.errorMessenger.Output( 144, "", cp );
562	}
563
564	RELATIVE_VAR RelativeVar;
565
566	//変数のアドレスを取得
567	if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
568
569	int beforeType = resultType.GetBasicType();
570
571	resultType.PtrLevelUp();
572
573	SetVarPtrToEax(&RelativeVar);
574	}
575	void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
576	if( isCallOn == false ){
577	// 戻り値の型を取得するだけ
578
579	//変数のアドレスを取得
580	if(!GetVarType( Parameter, resultType, true )) return;
581
582	resultType.PtrLevelUp();
583
584	return;
585	}
586
587	RELATIVE_VAR RelativeVar;
588
589	//変数のアドレスを取得
590	if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
591
592	int beforeType = resultType.GetBasicType();
593
594	resultType.PtrLevelUp();
595
596	SetVarPtrToEax(&RelativeVar);
597
598	if( lstrcmpi( Parameter, "This" )==0 ){
599	// Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
600	}
601	else if( beforeType == DEF_OBJECT ){
602	//参照をオブジェクトポインタに変更
603
604	//mov eax,dword ptr[eax]
605	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
606	}
607	else{
608	compiler.errorMessenger.Output(134,NULL,cp );
609	}
610	}
611
612	void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
613	{
614	if( isCallOn )
615	{
616	int i = 0;
617	char methodPtrParamStr[VN_SIZE];
618	i = GetOneParameter( paramsStr, i, methodPtrParamStr );
619
620	char objPtrValueStr[VN_SIZE]="";
621	if( isDynamicCall )
622	{
623	i = GetOneParameter( paramsStr, i, objPtrValueStr );
624	}
625
626	Opcode_CallDelegate( compiler.GetObjectModule().meta.ToDelegate( compiler.GetCompilingClass() ), methodPtrParamStr, objPtrValueStr, paramsStr + i );
627	}
628
629	resultType = compiler.GetCompilingUserProc().ReturnType();
630	}
631	void Opcode_Func_System_Get_Bp()
632	{
633	//mov eax,ebp
634	compiler.codeGenerator.op_mov_RR(REG_EAX,REG_EBP);
635	}
636	void Opcode_Func_System_Get_Sp()
637	{
638	//mov eax,esp
639	compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESP);
640	}
641
642	void Opcode_Func_System_GetComVtbl( const char *parameter )
643	{
644	Type classType;
645	compiler.StringToType( parameter, classType );
646
647	// mov eax,com_vtbl
648	compiler.codeGenerator.op_mov_RV_com_vtbl( REG_EAX, &classType.GetClass() );
649	}
650	void Opcode_Func_System_GetVtblList( const char *parameter )
651	{
652	Type classType;
653	compiler.StringToType( parameter, classType );
654
655	// mov eax,com_vtbl
656	compiler.codeGenerator.op_mov_RV_vtbl( REG_EAX, &classType.GetClass() );
657	}
658	void Opcode_Func_System_GetDefaultConstructor( const char *parameter )
659	{
660	Type classType;
661	compiler.StringToType( parameter, classType );
662
663	if( classType.GetClass().GetConstructorMethod() )
664	{
665	//mov eax,ProcAddr
666	compiler.codeGenerator.op_addressof( REG_EAX, &classType.GetClass().GetConstructorMethod()->GetUserProc() );
667	}
668	else
669	{
670	// デフォルトコンストラクタを持たない
671
672	//xor eax,eax
673	compiler.codeGenerator.op_zero_reg( REG_EAX );
674	}
675	}
676	void Opcode_Func_System_GetDestructor( const char *parameter )
677	{
678	Type classType;
679	compiler.StringToType( parameter, classType );
680
681	//mov eax,ProcAddr
682	compiler.codeGenerator.op_addressof( REG_EAX, &classType.GetClass().GetDestructorMethod()->GetUserProc() );
683	}
684
685	void Opcode_Func_GetPtrData(const char *Parameter,const int type){
686	Type tempType;
687	if( !NumOpe(Parameter,Type(),tempType) ){
688	return;
689	}
690	if(!tempType.IsWhole()){
691	compiler.errorMessenger.Output(11,Parameter,cp);
692	return;
693	}
694	ChangeTypeToLong(tempType.GetBasicType());
695
696	if(type==DEF_DOUBLE){
697	//pop eax
698	compiler.codeGenerator.op_pop(REG_EAX);
699
700	//fld qword ptr[eax]
701	compiler.codeGenerator.PutOld(
702	(char)0xDD,
703	(char)0x00
704	);
705	}
706	else if(type==DEF_SINGLE\|\|type==DEF_DWORD){
707	//pop eax
708	compiler.codeGenerator.op_pop(REG_EAX);
709
710	//mov eax,dword ptr[eax]
711	compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
712	}
713	else if(type==DEF_QWORD){
714	//pop ecx
715	compiler.codeGenerator.op_pop(REG_ECX);
716
717	//mov eax,dword ptr[ecx]
718	compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);
719
720	//mov edx,dword ptr[ecx+sizeof(long)]
721	compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);
722	}
723	else if(type==DEF_WORD){
724	//pop ebx
725	compiler.codeGenerator.op_pop(REG_EBX);
726
727	//xor eax,eax
728	compiler.codeGenerator.op_xor_RR(REG_EAX);
729
730	//mov ax,word ptr[ebx]
731	compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_EBX, 0, MOD_BASE );
732	}
733	else if(type==DEF_BYTE){
734	//pop ebx
735	compiler.codeGenerator.op_pop(REG_EBX);
736
737	//xor eax,eax
738	compiler.codeGenerator.op_xor_RR(REG_EAX);
739
740	//mov al,byte ptr[ebx]
741	compiler.codeGenerator.op_mov_RM( sizeof(char), REG_EAX, REG_EBX, 0, MOD_BASE );
742	}
743	}
744
745	bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
746	{
747	switch(FuncNum){
748	case FUNC_FIX:
749	if( isCallOn ) Opcode_Func_Fix(Parameter);
750	resultType.SetBasicType( DEF_LONG );
751	break;
752	case FUNC_CUDBL:
753	if( isCallOn ) Opcode_Func_CUDbl(Parameter);
754	resultType.SetBasicType( DEF_DOUBLE );
755	break;
756	case FUNC_LEN:
757	if( isCallOn ) Opcode_Func_Len(Parameter);
758	resultType.SetBasicType( DEF_LONG );
759	break;
760	case FUNC_ADDRESSOF:
761	Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
762	break;
763	case FUNC_SIZEOF:
764	if( isCallOn ) Opcode_Func_SizeOf(Parameter);
765	resultType.SetBasicType( DEF_LONG );
766	break;
767	case FUNC_CLASS_SIZEOF:
768	if( isCallOn ) Opcode_Func_ClassSizeOf(Parameter);
769	resultType.SetBasicType( DEF_LONG );
770	break;
771	case FUNC_VARPTR:
772	Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
773	break;
774	case FUNC_OBJPTR:
775	Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
776	break;
777	case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
778	Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
779	break;
780	case FUNC_DELEGATE_STATICMETHOD_CALL:
781	Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
782	break;
783	case FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS:
784	if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeCatchAddress();
785	resultType.SetBasicType( DEF_PTR_VOID );
786	break;
787	case FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS:
788	if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeFinallyAddress();
789	resultType.SetBasicType( DEF_PTR_VOID );
790	break;
791	case FUNC_SYSTEM_GET_BP:
792	if( isCallOn ) Opcode_Func_System_Get_Bp();
793	resultType.SetBasicType( DEF_LONG );
794	break;
795	case FUNC_SYSTEM_GET_SP:
796	if( isCallOn ) Opcode_Func_System_Get_Sp();
797	resultType.SetBasicType( DEF_LONG );
798	break;
799	case FUNC_SYSTEM_GET_COM_VTBL:
800	if( isCallOn ) Opcode_Func_System_GetComVtbl( Parameter );
801	resultType.SetBasicType( DEF_PTR_VOID );
802	break;
803	case FUNC_SYSTEM_GET_VTBL_LIST:
804	if( isCallOn ) Opcode_Func_System_GetVtblList( Parameter );
805	resultType.SetBasicType( DEF_PTR_VOID );
806	break;
807	case FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR:
808	if( isCallOn ) Opcode_Func_System_GetDefaultConstructor( Parameter );
809	resultType.SetBasicType( DEF_PTR_VOID );
810	break;
811	case FUNC_SYSTEM_GET_DESTRUCTOR:
812	if( isCallOn ) Opcode_Func_System_GetDestructor( Parameter );
813	resultType.SetBasicType( DEF_PTR_VOID );
814	break;
815
816	case FUNC_GETDOUBLE:
817	if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
818	resultType.SetBasicType( DEF_DOUBLE );
819	break;
820	case FUNC_GETSINGLE:
821	if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
822	resultType.SetBasicType( DEF_SINGLE );
823	break;
824	case FUNC_GETQWORD:
825	if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
826	resultType.SetBasicType( DEF_QWORD );
827	break;
828	case FUNC_GETDWORD:
829	if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
830	resultType.SetBasicType( DEF_DWORD );
831	break;
832	case FUNC_GETWORD:
833	if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
834	resultType.SetBasicType( DEF_WORD );
835	break;
836	case FUNC_GETBYTE:
837	if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
838	resultType.SetBasicType( DEF_BYTE );
839	break;
840	default:
841	return false;
842	}
843	return true;
844	}

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

Download in other formats: