source: dev/trunk/ab5.0/abdev/BasicCompiler64/Compile_Func.cpp@ 463

Last change on this file since 463 was 463, checked in by dai_9181, 16 years ago

[461]を64bit版にマージ。
File size: 18.7 KB
Line 
1#include "stdafx.h"
2
3#include <Compiler.h>
4
5#include "../BasicCompiler_Common/common.h"
6#include "Opcode.h"
7
8#ifdef _AMD64_
9#include "../BasicCompiler64/FunctionValue.h"
10#else
11#include "../BasicCompiler32/FunctionValue.h"
12#endif
13
14int GetFunctionFromName(char *FuncName){
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, "VarPtr" ) == 0 ) return FUNC_VARPTR;
19 if( lstrcmpi( FuncName, "ObjPtr" ) == 0 ) return FUNC_OBJPTR;
20 if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 ) return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
21 if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 ) return FUNC_DELEGATE_STATICMETHOD_CALL;
22 if( lstrcmpi( FuncName, "_System_GetNowScopeCatchAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS;
23 if( lstrcmpi( FuncName, "_System_GetNowScopeFinallyAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS;
24 if( lstrcmpi( FuncName, "_System_GetBp" ) == 0 ) return FUNC_SYSTEM_GET_BP;
25 if( lstrcmpi( FuncName, "_System_GetSp" ) == 0 ) return FUNC_SYSTEM_GET_SP;
26 if( lstrcmp( FuncName, "_System_GetComVtbl" ) == 0 ) return FUNC_SYSTEM_GET_COM_VTBL;
27 if( lstrcmp( FuncName, "_System_GetVtblList" ) == 0 ) return FUNC_SYSTEM_GET_VTBL_LIST;
28 if( lstrcmp( FuncName, "_System_GetDefaultConstructor" ) == 0 ) return FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR;
29 if( lstrcmp( FuncName, "_System_GetDestructor" ) == 0 ) return FUNC_SYSTEM_GET_DESTRUCTOR;
30 if( lstrcmpi( FuncName, "GetDouble" ) == 0 ) return FUNC_GETDOUBLE;
31 if( lstrcmpi( FuncName, "GetSingle" ) == 0 ) return FUNC_GETSINGLE;
32 if( lstrcmpi( FuncName, "GetQWord" ) == 0 ) return FUNC_GETQWORD;
33 if( lstrcmpi( FuncName, "GetDWord" ) == 0 ) return FUNC_GETDWORD;
34 if( lstrcmpi( FuncName, "GetWord" ) == 0 ) return FUNC_GETWORD;
35 if( lstrcmpi( FuncName, "GetByte" ) == 0 ) return FUNC_GETBYTE;
36 return 0;
37}
38void Opcode_Func_Len( const char *Parameter ){
39 BOOL bArrayHead;
40
41 const char *tempParm=Parameter;
42 char temporary[VN_SIZE];
43 char temp2[32];
44 Type type;
45 if( !GetVarType(Parameter,type,0) ){
46 sprintf(temporary,"_System_DummyStr2=%s",Parameter);
47 OpcodeCalc(temporary);
48
49 lstrcpy(temp2,"_System_DummyStr2");
50 tempParm=temp2;
51
52 type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
53 }
54
55 if( type.IsStringClass() ){
56 //Stringオブジェクトの場合
57 sprintf(temporary,"%s.Length",tempParm);
58
59 int reg=REG_RAX;
60 NumOpe(&reg,temporary,Type(),Type());
61 return;
62 }
63
64 Subscripts subscripts;
65 RELATIVE_VAR RelativeVar;
66 if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
67
68 if(type.GetBasicType()&FLAG_PTR){
69 type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
70
71 bArrayHead=1;
72 }
73 else bArrayHead=0;
74
75 int typeSize = type.GetSize();
76
77 if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
78
79 //mov rax,TypeSize
80 compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
81
82 return;
83}
84
85void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
86{
87 if( userProc.IsVirtual() )
88 {
89 ///////////////////////////////
90 // 仮想関数の場合
91 // thisポインタをrcxにコピー
92 ///////////////////////////////
93
94 const CClass *pobj_c;
95
96 char ObjectName[VN_SIZE];
97 ReferenceKind referenceKind;
98 SplitObjectName(methodInstanceName,ObjectName, referenceKind );
99
100 if(ObjectName[0]){
101 if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
102 else{
103 RELATIVE_VAR RelativeVar;
104 Type type;
105 if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
106 SetVarPtrToReg(REG_RCX,&RelativeVar);
107
108 //参照タイプが整合しているかをチェック
109 if( !( type.IsObject() && referenceKind == RefDot
110 || type.IsObjectPtr() && referenceKind == RefPointer ) )
111 {
112 SetError(104,ObjectName,cp);
113 }
114
115 if(type.IsObjectPtr()){
116 //mov rcx,qword ptr[rcx]
117 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
118 }
119 }
120 }
121 else{
122InClassMember:
123 //自身のオブジェクトのThisポインタをrcxにコピー
124 SetThisPtrToReg(REG_RCX);
125
126 pobj_c=compiler.pCompilingClass;
127 }
128
129
130 int vtblIndex;
131 if( pobj_c->IsInterface() )
132 {
133 // インターフェイスメソッド
134
135 int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
136
137 // vtblのポインタを取得
138 //mov r11,qword ptr[rcx+offset_vtbl]
139 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,offset_vtbl,MOD_BASE_DISP8);
140
141 int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
142
143 // インターフェイスの場合は更に__thisを取得する
144 //mov rcx,qword ptr[rcx+offset_this]
145 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,offset_this,MOD_BASE_DISP8);
146
147 int vtblMasterListIndex;
148 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
149 if( vtblMasterListIndex != 0 )
150 {
151 SetError();
152 }
153 }
154 else if( pobj_c->IsComInterface() )
155 {
156 //仮想関数（オブジェクトメソッド）
157 // pObj -> vtbl1 -> func1
158 // -> func2
159 // -> func3
160
161 int vtblMasterListIndex;
162 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
163
164 // vtblのポインタを取得
165 //mov r11,qword ptr[rcx]
166 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
167 }
168 else
169 {
170 //仮想関数（オブジェクトメソッド）
171 // pObj -> vtbl_master_list -> vtbl1 -> func1
172 // -> func2
173 // -> func3
174 // -> vtbl2 -> func1
175 // -> func2
176 // -> func3
177
178 int vtblMasterListIndex;
179 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
180
181 // vtblマスターリストのポインタを取得
182 //mov r11,qword ptr[rcx+sizeof(com_vtbl)]
183 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,PTR_SIZE,MOD_BASE_DISP8);
184
185 // vtblのポインタを取得
186 //mov r11,dword ptr[r11+vtblMasterListIndex]
187 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_R11, REG_R11, vtblMasterListIndex, MOD_BASE_DISP32 );
188 }
189
190 //mov rax,qword ptr[r11+func_index]
191 if( vtblIndex * PTR_SIZE <= 0x7F )
192 {
193 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,vtblIndex*PTR_SIZE,MOD_BASE_DISP8);
194 }
195 else
196 {
197 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,vtblIndex*PTR_SIZE,MOD_BASE_DISP32);
198 }
199 }
200 else{
201 //一般の関数
202
203 //mov rax,ProcAddr
204 compiler.codeGenerator.op_addressof( REG_RAX, &userProc );
205 }
206
207 userProc.Using();
208}
209void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
210{
211 /////////////////////////////////////////////////////////////////
212 // 関数ポインタをpush
213 /////////////////////////////////////////////////////////////////
214
215 //mov rax,AddressOf
216 _Opcode_Func_AddressOf( methodInstanceName, userProc );
217
218
219 if( userProc.GetMethod().IsDynamic() )
220 {
221 //mov rdx,rax
222 compiler.codeGenerator.op_mov_RR( REG_RDX, REG_RAX );
223
224 pobj_BlockReg->lock( REG_RDX );
225
226
227 /////////////////////////////////////////////////////////////////
228 // オブジェクト ポインタをpush
229 /////////////////////////////////////////////////////////////////
230
231 // オブジェクト名を取得
232 char objectName[VN_SIZE];
233 char memberName[VN_SIZE];
234 char *thisPtrName = "This";
235 Type type;
236 if( SplitMemberName( methodInstanceName, objectName, memberName ) )
237 {
238 if( GetVarType( objectName, type, false ) )
239 {
240 thisPtrName = objectName;
241 }
242 }
243
244 // オブジェクト ポインタを取得
245 RELATIVE_VAR relativeVar;
246 GetVarOffsetReadOnly( thisPtrName, &relativeVar, type );
247 if( !type.IsObject() )
248 {
249 extern int cp;
250 SetError(1,NULL,cp);
251 return;
252 }
253
254 SetVarPtrToReg( REG_RAX, &relativeVar );
255
256 //mov rcx,dword ptr[rax]
257 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RCX, REG_RAX, 0, MOD_BASE );
258
259 pobj_BlockReg->unlock( REG_RDX );
260 }
261 else
262 {
263 //mov rcx,rax
264 compiler.codeGenerator.op_mov_RR( REG_RCX, REG_RAX );
265 }
266
267
268 /////////////////////////////////////////////////////////////////
269 // call _CreateDynamicDelegate/_CreateStaticDelegate
270 /////////////////////////////////////////////////////////////////
271
272 std::vector<const UserProc *> subs;
273 if( userProc.GetMethod().IsDynamic() )
274 {
275 dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
276 }
277 else
278 {
279 dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
280 }
281
282 // call _CreateDynamicDelegate
283 compiler.codeGenerator.op_call( subs[0] );
284}
285void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
286{
287 extern int cp;
288
289 const Parameters *pBaseParams = NULL;
290 const Type *pBaseReturnType = NULL;
291 if( baseType.IsProcPtr() )
292 {
293 // 左辺で関数ポインタを要求されているとき
294 const ProcPointer *pTempProcPointer = compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()];
295 pBaseParams = &pTempProcPointer->Params();
296 pBaseReturnType = &pTempProcPointer->ReturnType();
297 }
298 else if( baseType.IsDelegate() )
299 {
300 // 左辺でデリゲートを要求されているとき
301 const Delegate *pTempDelegate = &baseType.GetClass().GetDelegate();
302 pBaseParams = &pTempDelegate->Params();
303 pBaseReturnType = &pTempDelegate->ReturnType();
304 }
305
306 const UserProc *pUserProc;
307 if( pBaseParams && pBaseReturnType )
308 {
309 //左辺の型にのっとり、オーバーロードを解決
310
311 std::vector<const UserProc *> subs;
312 GetOverloadSubHash( name, subs );
313 if( subs.size() == 0 ){
314 SetError(27,name,cp);
315 return;
316 }
317
318 //オーバーロードを解決
319 pUserProc=OverloadSolution( name, subs, *pBaseParams, Type(), Type() );
320
321 if( isCallOn )
322 {
323 // コード生成を伴う場合はエラーチェックを行う
324
325 if( baseType.IsDelegate() )
326 {
327 // デリゲート
328 // 共変戻り値、反変引数をサポート
329 if( !(
330 pBaseParams->Equals( pUserProc->Params(), true )
331 && ( pBaseReturnType->Equals( pUserProc->ReturnType() ) || pBaseReturnType->IsCovariant( pUserProc->ReturnType() ) )
332 ) )
333 {
334 SetError(67, name, cp );
335 }
336 }
337 else
338 {
339 // 関数ポインタ
340 if( !(
341 pBaseParams->Equals( pUserProc->Params() )
342 && pBaseReturnType->Equals( pUserProc->ReturnType() )
343 ) )
344 {
345 SetError(66, name, cp );
346 }
347 }
348 }
349
350 if(!pUserProc){
351 SetError(27,name,cp);
352 return;
353 }
354 }
355 else{
356 pUserProc=GetSubHash(name);
357 if(!pUserProc){
358 SetError(27,name,cp);
359 return;
360 }
361 }
362
363 if( baseType.IsDelegate() )
364 {
365 if( isCallOn )
366 {
367 // デリゲートのとき
368 Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
369 }
370 resultType = baseType;
371 }
372 else
373 {
374 if( isCallOn )
375 {
376 // 関数ポインタのとき
377 _Opcode_Func_AddressOf( name, *pUserProc );
378 }
379 resultType.SetBasicType( DEF_PTR_VOID );
380 }
381}
382void Opcode_Func_SizeOf( const string &typeName ){
383 Type tempType;
384 if( !compiler.StringToType( typeName, tempType ) ){
385 SetError(3,typeName,cp);
386 return;
387 }
388
389 int typeSize = ( tempType.IsObject() ) ?
390 tempType.GetClass().GetSize() : tempType.GetSize();
391
392 //mov rax,size
393 compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
394}
395void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
396 if( isCallOn == false ){
397 // 戻り値の型を取得するだけ
398
399 //変数のアドレスを取得
400 if(!GetVarType( Parameter, resultType, true )) return;
401
402 resultType.PtrLevelUp();
403
404 return;
405 }
406
407 RELATIVE_VAR RelativeVar;
408
409 //変数のアドレスを取得
410 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
411
412 int beforeType = resultType.GetBasicType();
413
414 resultType.PtrLevelUp();
415
416 SetVarPtrToReg(REG_RAX,&RelativeVar);
417
418 // TODO: 取り除く（この動きはObjPtrに託す）
419 /*
420 if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
421 //参照をオブジェクトポインタに変更
422
423 //mov rax,qword ptr[rax]
424 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
425
426 SetError(-120,NULL,cp);
427 }*/
428}
429void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
430 if( isCallOn == false ){
431 // 戻り値の型を取得するだけ
432
433 //変数のアドレスを取得
434 if(!GetVarType( Parameter, resultType, true )) return;
435
436 resultType.PtrLevelUp();
437
438 return;
439 }
440
441 RELATIVE_VAR RelativeVar;
442
443 //変数のアドレスを取得
444 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
445
446 int beforeType = resultType.GetBasicType();
447
448 resultType.PtrLevelUp();
449
450 SetVarPtrToReg(REG_RAX,&RelativeVar);
451
452 if( lstrcmpi( Parameter, "This" )==0 ){
453 // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
454 }
455 else if( beforeType == DEF_OBJECT ){
456 //参照をオブジェクトポインタに変更
457
458 //mov rax,qword ptr[rax]
459 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
460 }
461 else{
462 SetError(134,NULL,cp );
463 }
464}
465
466void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
467{
468 if( isCallOn )
469 {
470 int i = 0;
471 char methodPtrParamStr[VN_SIZE];
472 i = GetOneParameter( paramsStr, i, methodPtrParamStr );
473
474 char objPtrValueStr[VN_SIZE] = "";
475 if( isDynamicCall )
476 {
477 i = GetOneParameter( paramsStr, i, objPtrValueStr );
478 }
479
480 Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
481 }
482
483 resultType = UserProc::CompilingUserProc().ReturnType();
484}
485
486void Opcode_Func_System_Get_Bp()
487{
488 //mov rax,rbp
489 compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RBP);
490}
491void Opcode_Func_System_Get_Sp()
492{
493 //mov rax,rsp
494 compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RSP);
495}
496
497void Opcode_Func_System_GetComVtbl( const char *parameter )
498{
499 Type classType;
500 compiler.StringToType( parameter, classType );
501
502 // mov rax,com_vtbl
503 compiler.codeGenerator.op_mov_RV_com_vtbl( REG_RAX, &classType.GetClass() );
504}
505void Opcode_Func_System_GetVtblList( const char *parameter )
506{
507 Type classType;
508 compiler.StringToType( parameter, classType );
509
510 // mov rax,com_vtbl
511 compiler.codeGenerator.op_mov_RV_vtbl( REG_RAX, &classType.GetClass() );
512}
513void Opcode_Func_System_GetDefaultConstructor( const char *parameter )
514{
515 Type classType;
516 compiler.StringToType( parameter, classType );
517
518 if( classType.GetClass().GetConstructorMethod() )
519 {
520 //mov rax,ProcAddr
521 compiler.codeGenerator.op_addressof( REG_RAX, &classType.GetClass().GetConstructorMethod()->GetUserProc() );
522 }
523 else
524 {
525 // デフォルトコンストラクタを持たない
526
527 //xor rax,rax
528 compiler.codeGenerator.op_zero_reg( REG_RAX );
529 }
530}
531void Opcode_Func_System_GetDestructor( const char *parameter )
532{
533 Type classType;
534 compiler.StringToType( parameter, classType );
535
536 //mov rax,ProcAddr
537 compiler.codeGenerator.op_addressof( REG_RAX, &classType.GetClass().GetDestructorMethod()->GetUserProc() );
538}
539
540void Opcode_Func_GetPtrData( const char *Parameter, const int type ){
541 int reg=REG_RAX;
542 Type tempType;
543 if( !NumOpe(&reg,Parameter,Type(),tempType) ){
544 return;
545 }
546 if(!tempType.IsWhole()){
547 SetError(11,Parameter,cp);
548 return;
549 }
550
551 if(type==DEF_DOUBLE){
552 //movlpd xmm0,qword ptr[rax]
553 compiler.codeGenerator.op_movlpd_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
554 }
555 else if(type==DEF_SINGLE){
556 //movss xmm0,dword ptr[rax]
557 compiler.codeGenerator.op_movss_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
558 }
559 else{
560 //mov rax,ptr[rax]
561 compiler.codeGenerator.op_mov_RM(Type(type).GetSize(),REG_RAX,REG_RAX,0,MOD_BASE);
562 }
563}
564
565bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
566{
567 switch(FuncNum){
568 case FUNC_LEN:
569 if( isCallOn ) Opcode_Func_Len(Parameter);
570 resultType.SetBasicType( DEF_LONG );
571 break;
572 case FUNC_ADDRESSOF:
573 Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
574 break;
575 case FUNC_SIZEOF:
576 if( isCallOn ) Opcode_Func_SizeOf(Parameter);
577 resultType.SetBasicType( DEF_LONG );
578 break;
579 case FUNC_VARPTR:
580 Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
581 break;
582 case FUNC_OBJPTR:
583 Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
584 break;
585 case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
586 Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
587 break;
588 case FUNC_DELEGATE_STATICMETHOD_CALL:
589 Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
590 break;
591 case FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS:
592 if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeCatchAddress();
593 resultType.SetBasicType( DEF_PTR_VOID );
594 break;
595 case FUNC_SYSTEM_GET_NOW_SCOPE_FINALLY_ADDRESS:
596 if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeFinallyAddress();
597 resultType.SetBasicType( DEF_PTR_VOID );
598 break;
599 case FUNC_SYSTEM_GET_BP:
600 if( isCallOn ) Opcode_Func_System_Get_Bp();
601 resultType.SetBasicType( DEF_INT64 );
602 break;
603 case FUNC_SYSTEM_GET_SP:
604 if( isCallOn ) Opcode_Func_System_Get_Sp();
605 resultType.SetBasicType( DEF_INT64 );
606 break;
607 case FUNC_SYSTEM_GET_COM_VTBL:
608 if( isCallOn ) Opcode_Func_System_GetComVtbl( Parameter );
609 resultType.SetBasicType( DEF_PTR_VOID );
610 break;
611 case FUNC_SYSTEM_GET_VTBL_LIST:
612 if( isCallOn ) Opcode_Func_System_GetVtblList( Parameter );
613 resultType.SetBasicType( DEF_PTR_VOID );
614 break;
615 case FUNC_SYSTEM_GET_DEFAULT_CONSTRUCTOR:
616 if( isCallOn ) Opcode_Func_System_GetDefaultConstructor( Parameter );
617 resultType.SetBasicType( DEF_PTR_VOID );
618 break;
619 case FUNC_SYSTEM_GET_DESTRUCTOR:
620 if( isCallOn ) Opcode_Func_System_GetDestructor( Parameter );
621 resultType.SetBasicType( DEF_PTR_VOID );
622 break;
623
624 case FUNC_GETDOUBLE:
625 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
626 resultType.SetBasicType( DEF_DOUBLE );
627 break;
628 case FUNC_GETSINGLE:
629 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
630 resultType.SetBasicType( DEF_SINGLE );
631 break;
632 case FUNC_GETQWORD:
633 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
634 resultType.SetBasicType( DEF_QWORD );
635 break;
636 case FUNC_GETDWORD:
637 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
638 resultType.SetBasicType( DEF_DWORD );
639 break;
640 case FUNC_GETWORD:
641 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
642 resultType.SetBasicType( DEF_WORD );
643 break;
644 case FUNC_GETBYTE:
645 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
646 resultType.SetBasicType( DEF_BYTE );
647 break;
648 default:
649 return false;
650 }
651 return true;
652}
Note: See TracBrowser for help on using the repository browser.